@nocobase/plugin-flow-engine 2.0.0-alpha.7 → 2.0.0-alpha.71

package/dist/server/repository.d.ts

@@ -8,7 +8,7 @@
  */
 import { Cache } from '@nocobase/cache';
 import { Repository, Transaction, Transactionable } from '@nocobase/database';
-import { ChildOptions, SchemaNode } from './dao/ui_schema_node_dao';
+import { ChildOptions, SchemaNode, TargetPosition } from './dao/ui_schema_node_dao';
 export interface GetJsonSchemaOptions {
     includeAsyncNode?: boolean;
     readFromCache?: boolean;
@@ -18,6 +18,13 @@ export interface GetPropertiesOptions {
     readFromCache?: boolean;
     transaction?: Transaction;
 }
+export type FlowModelAttachPosition = 'first' | 'last' | TargetPosition;
+export interface FlowModelAttachOptions {
+    parentId: string;
+    subKey: string;
+    subType: 'array' | 'object';
+    position?: FlowModelAttachPosition;
+}
 type BreakRemoveOnType = {
     [key: string]: any;
 };
@@ -51,6 +58,7 @@ export declare class FlowModelRepository extends Repository {
     getParentJsonSchema(uid: string, options?: GetJsonSchemaOptions): Promise<any>;
     getParentProperty(uid: string, options?: GetPropertiesOptions): Promise<any>;
     getJsonSchema(uid: string, options?: GetJsonSchemaOptions): Promise<any>;
+    static optionsToJson(options: any): any;
     nodesToSchema(nodes: any, rootUid: any): {
         uid: any;
         "x-async": boolean;
@@ -70,7 +78,9 @@ export declare class FlowModelRepository extends Repository {
     }): Promise<void>;
     remove(uid: string, options?: Transactionable & removeParentOptions): Promise<void>;
     insertAdjacent(position: 'beforeBegin' | 'afterBegin' | 'beforeEnd' | 'afterEnd', target: string, schema: any, options?: InsertAdjacentOptions): Promise<any>;
-    duplicate(uid: string, options?: Transactionable): Promise<any>;
+    duplicate(modelUid: string, options?: Transactionable): Promise<any>;
+    private dedupeNodesForDuplicate;
+    private replaceStepParamsModelUids;
     insert(schema: any, options?: Transactionable): Promise<any>;
     insertNewSchema(schema: any, options?: Transactionable & {
         returnNode?: boolean;
@@ -111,6 +121,7 @@ export declare class FlowModelRepository extends Repository {
     findModelByParentId(parentUid: string, options?: GetJsonSchemaOptions & {
         subKey?: string;
     }): Promise<any>;
+    attach(uid: string, attachOptions: FlowModelAttachOptions, options?: Transactionable): Promise<any>;
     move(options: any): Promise<any>;
 }
 export default FlowModelRepository;

package/dist/server/repository.js

@@ -204,6 +204,9 @@ const _FlowModelRepository = class _FlowModelRepository extends import_database.
     }
     return this.doGetJsonSchema(uid2, options);
   }
+  static optionsToJson(options) {
+    return import_lodash.default.isPlainObject(options) ? options : JSON.parse(options);
+  }
   nodesToSchema(nodes, rootUid) {
     const nodeAttributeSanitize = (node) => {
       const schema = {
@@ -426,13 +429,122 @@ const _FlowModelRepository = class _FlowModelRepository extends import_database.
     await this.clearXUidPathCache(result["uid"], transaction2);
     return result;
   }
-  async duplicate(uid2, options) {
-    const s = await this.getJsonSchema(uid2, { ...options, includeAsyncNode: true });
-    if (!(s == null ? void 0 : s["uid"])) {
+  async duplicate(modelUid, options) {
+    let nodes = await this.findNodesById(modelUid, { ...options, includeAsyncNode: true });
+    if (!(nodes == null ? void 0 : nodes.length)) {
       return null;
     }
-    this.regenerateUid(s);
-    return this.insert(s, options);
+    nodes = this.dedupeNodesForDuplicate(nodes, modelUid);
+    const uidMap = {};
+    for (const n of nodes) {
+      uidMap[n["uid"]] = (0, import_utils.uid)();
+    }
+    const sorted = [...nodes].sort((a, b) => {
+      if (a.depth !== b.depth) return a.depth - b.depth;
+      const ap = a.parent || "";
+      const bp = b.parent || "";
+      if (ap !== bp) return ap < bp ? -1 : 1;
+      const at = a.type || "";
+      const bt = b.type || "";
+      if (at !== bt) return at < bt ? -1 : 1;
+      const as = a.sort ?? 0;
+      const bs = b.sort ?? 0;
+      return as - bs;
+    });
+    for (const n of sorted) {
+      const oldUid = n["uid"];
+      const newUid = uidMap[oldUid];
+      const oldParentUid = n["parent"];
+      const newParentUid = uidMap[oldParentUid] ?? null;
+      const optionsObj = this.replaceStepParamsModelUids(
+        import_lodash.default.isPlainObject(n.options) ? n.options : JSON.parse(n.options),
+        uidMap
+      );
+      if (newParentUid) {
+        optionsObj.parent = newParentUid;
+        optionsObj.parentId = newParentUid;
+      }
+      const schemaNode = {
+        uid: newUid,
+        ["x-async"]: !!n.async,
+        ...optionsObj
+      };
+      if (newParentUid) {
+        schemaNode.childOptions = {
+          parentUid: newParentUid,
+          type: n.type,
+          position: "last"
+        };
+      }
+      await this.insertSingleNode(schemaNode, { transaction: options == null ? void 0 : options.transaction });
+    }
+    return this.findModelById(uidMap[modelUid], { ...options });
+  }
+  dedupeNodesForDuplicate(nodes, rootUid) {
+    if (!Array.isArray(nodes) || nodes.length <= 1) {
+      return nodes;
+    }
+    const rowsByUid = import_lodash.default.groupBy(nodes, "uid");
+    const uniqueUids = Object.keys(rowsByUid);
+    if (uniqueUids.length === nodes.length) {
+      return nodes;
+    }
+    const uidsInSubtree = new Set(uniqueUids);
+    const rootDepthByUid = /* @__PURE__ */ new Map();
+    for (const uid2 of uniqueUids) {
+      const rows = rowsByUid[uid2] || [];
+      const depths = rows.map((row) => Number((row == null ? void 0 : row.depth) ?? 0));
+      rootDepthByUid.set(uid2, depths.length ? Math.min(...depths) : 0);
+    }
+    const pickRowForUid = (uid2, rows) => {
+      if (!(rows == null ? void 0 : rows.length)) return null;
+      if (rows.length === 1) return rows[0];
+      if (uid2 === rootUid) return rows[0];
+      let bestRow = rows[0];
+      let bestParentRootDepth = -1;
+      for (const row of rows) {
+        const parentUid = row == null ? void 0 : row.parent;
+        if (!parentUid || !uidsInSubtree.has(parentUid)) {
+          continue;
+        }
+        const parentRootDepth = rootDepthByUid.get(parentUid) ?? -1;
+        if (parentRootDepth > bestParentRootDepth) {
+          bestParentRootDepth = parentRootDepth;
+          bestRow = row;
+        }
+      }
+      return bestRow;
+    };
+    const uidsInQueryOrder = [];
+    const seenUidsInQueryOrder = /* @__PURE__ */ new Set();
+    for (const row of nodes) {
+      const uid2 = row == null ? void 0 : row.uid;
+      if (!uid2 || seenUidsInQueryOrder.has(uid2)) continue;
+      seenUidsInQueryOrder.add(uid2);
+      uidsInQueryOrder.push(uid2);
+    }
+    return uidsInQueryOrder.map((uid2) => pickRowForUid(uid2, rowsByUid[uid2])).filter(Boolean);
+  }
+  replaceStepParamsModelUids(options, uidMap) {
+    const opts = options && typeof options === "object" ? options : {};
+    const replaceUidString = (v) => typeof v === "string" && uidMap[v] ? uidMap[v] : v;
+    const replaceInPlace = (val) => {
+      if (Array.isArray(val)) {
+        for (let i = 0; i < val.length; i++) {
+          val[i] = replaceInPlace(val[i]);
+        }
+        return val;
+      }
+      if (val && typeof val === "object") {
+        for (const k of Object.keys(val)) {
+          val[k] = replaceInPlace(val[k]);
+        }
+        return val;
+      }
+      return replaceUidString(val);
+    };
+    if (opts.stepParams) opts.stepParams = replaceInPlace(opts.stepParams);
+    return opts;
   }
   async insert(schema, options) {
     const nodes = _FlowModelRepository.schemaToSingleNodes(schema);
@@ -1025,11 +1137,11 @@ WHERE TreeTable.depth = 1 AND  TreeTable.ancestor = :ancestor and TreeTable.sort
     const children = nodes.filter((n) => n.parent === rootUid);
     const subModels = {};
     for (const child of children) {
-      const { subKey, subType } = child.options;
+      const { subKey, subType } = this.optionsToJson(child.options);
       if (!subKey) continue;
       const model = _FlowModelRepository.nodesToModel(nodes, child["uid"]) || {
         uid: child["uid"],
-        ...child.options,
+        ...this.optionsToJson(child.options),
         sortIndex: child.sort
       };
       model.sortIndex = child.sort;
@@ -1055,7 +1167,7 @@ WHERE TreeTable.depth = 1 AND  TreeTable.ancestor = :ancestor and TreeTable.sort
     }
     return {
       uid: rootNode["uid"],
-      ...rootNode.options,
+      ...this.optionsToJson(rootNode.options),
       ...Object.keys(filteredSubModels).length > 0 ? { subModels: filteredSubModels } : {}
     };
   }
@@ -1136,6 +1248,141 @@ WHERE TreeTable.depth = 1 AND  TreeTable.ancestor = :ancestor and TreeTable.sort
     }
     return null;
   }
+  async attach(uid2, attachOptions, options) {
+    const { transaction: transaction2 } = options || {};
+    const modelUid = String(uid2 || "").trim();
+    const parentId = String((attachOptions == null ? void 0 : attachOptions.parentId) || "").trim();
+    const subKey = String((attachOptions == null ? void 0 : attachOptions.subKey) || "").trim();
+    const subType = attachOptions == null ? void 0 : attachOptions.subType;
+    if (!modelUid || !parentId || !subKey || subType !== "array" && subType !== "object") {
+      throw new Error("flowModels:attach missing required params");
+    }
+    if (modelUid === parentId) {
+      throw new Error("flowModels:attach cannot attach model to itself");
+    }
+    const treeTable = this.flowModelTreePathTableName;
+    const modelInstance = await this.model.findByPk(modelUid, { transaction: transaction2 });
+    if (!modelInstance) {
+      throw new Error(`flowModels:attach uid '${modelUid}' not found`);
+    }
+    const parentInstance = await this.model.findByPk(parentId, { transaction: transaction2 });
+    if (!parentInstance) {
+      throw new Error(`flowModels:attach parentId '${parentId}' not found`);
+    }
+    const cycle = await this.database.sequelize.query(
+      `SELECT 1 as v
+       FROM ${treeTable}
+       WHERE ancestor = :ancestor AND descendant = :descendant AND depth > 0
+       LIMIT 1`,
+      {
+        type: "SELECT",
+        replacements: {
+          ancestor: modelUid,
+          descendant: parentId
+        },
+        transaction: transaction2
+      }
+    );
+    if (cycle == null ? void 0 : cycle.length) {
+      throw new Error("flowModels:attach cycle detected");
+    }
+    if (subType === "object") {
+      const conflict = await this.database.sequelize.query(
+        `SELECT TreeTable.descendant as uid
+         FROM ${treeTable} as TreeTable
+                  LEFT JOIN ${treeTable} as NodeInfo
+                            ON NodeInfo.descendant = TreeTable.descendant
+                                AND NodeInfo.depth = 0
+         WHERE TreeTable.depth = 1
+           AND TreeTable.ancestor = :ancestor
+           AND NodeInfo.type = :type
+           AND TreeTable.descendant != :uid
+         LIMIT 1`,
+        {
+          type: "SELECT",
+          replacements: {
+            ancestor: parentId,
+            type: subKey,
+            uid: modelUid
+          },
+          transaction: transaction2
+        }
+      );
+      if (conflict == null ? void 0 : conflict.length) {
+        throw new Error(`flowModels:attach subKey '${subKey}' already exists on parent '${parentId}'`);
+      }
+    }
+    const normalizePosition = (input) => {
+      if (!input) return "last";
+      if (input === "first" || input === "last") return input;
+      if (typeof input === "object") {
+        const p = input;
+        const type = p == null ? void 0 : p.type;
+        const target = String((p == null ? void 0 : p.target) || "").trim();
+        if ((type === "before" || type === "after") && target) {
+          return { type, target };
+        }
+      }
+      throw new Error("flowModels:attach invalid position");
+    };
+    const position = subType === "object" ? "last" : normalizePosition(attachOptions == null ? void 0 : attachOptions.position);
+    if (typeof position === "object") {
+      const target = String(position.target || "").trim();
+      if (target === modelUid) {
+        throw new Error("flowModels:attach position target cannot be itself");
+      }
+      const ok = await this.database.sequelize.query(
+        `SELECT 1 as v
+         FROM ${treeTable} as TreeTable
+                  LEFT JOIN ${treeTable} as NodeInfo
+                            ON NodeInfo.descendant = TreeTable.descendant
+                                AND NodeInfo.depth = 0
+         WHERE TreeTable.depth = 1
+           AND TreeTable.ancestor = :ancestor
+           AND TreeTable.descendant = :descendant
+           AND NodeInfo.type = :type
+         LIMIT 1`,
+        {
+          type: "SELECT",
+          replacements: {
+            ancestor: parentId,
+            descendant: target,
+            type: subKey
+          },
+          transaction: transaction2
+        }
+      );
+      if (!(ok == null ? void 0 : ok.length)) {
+        throw new Error("flowModels:attach position target is not a sibling under the same parent/subKey");
+      }
+    }
+    await this.clearXUidPathCache(modelUid, transaction2);
+    await modelInstance.update(
+      {
+        options: {
+          ...modelInstance.get("options"),
+          parentId,
+          parent: parentId,
+          subKey,
+          subType
+        }
+      },
+      { transaction: transaction2, hooks: false }
+    );
+    await this.insertSingleNode(
+      {
+        uid: modelUid,
+        name: modelUid,
+        childOptions: {
+          parentUid: parentId,
+          type: subKey,
+          position
+        }
+      },
+      { transaction: transaction2, removeParentsIfNoChildren: false }
+    );
+    return await this.findModelById(modelUid, { transaction: transaction2, includeAsyncNode: true });
+  }
   async move(options) {
     const { sourceId, targetId, position } = options;
     return await this.insertAdjacent(position === "after" ? "afterEnd" : "beforeBegin", targetId, {
@@ -1200,6 +1447,9 @@ __decorateClass([
 __decorateClass([
   transaction()
 ], _FlowModelRepository.prototype, "upsertModel", 1);
+__decorateClass([
+  transaction()
+], _FlowModelRepository.prototype, "attach", 1);
 let FlowModelRepository = _FlowModelRepository;
 var repository_default = FlowModelRepository;
 // Annotate the CommonJS export names for ESM import in node:

package/dist/server/server.js

@@ -127,15 +127,34 @@ class PluginUISchemaStorageServer extends import_server.Plugin {
       name: "flowModels",
       actions: {
         findOne: async (ctx, next) => {
-          const { uid: uid2, parentId, subKey } = ctx.action.params;
+          const { uid: uid2, parentId, subKey, includeAsyncNode = false } = ctx.action.params;
           const repository = ctx.db.getRepository("flowModels");
           if (uid2) {
-            ctx.body = await repository.findModelById(uid2);
+            ctx.body = await repository.findModelById(uid2, { includeAsyncNode });
           } else if (parentId) {
-            ctx.body = await repository.findModelByParentId(parentId, { subKey });
+            ctx.body = await repository.findModelByParentId(parentId, { subKey, includeAsyncNode });
           }
           await next();
         },
+        duplicate: async (ctx, next) => {
+          const { uid: uid2 } = ctx.action.params;
+          const repository = ctx.db.getRepository("flowModels");
+          const duplicated = await repository.duplicate(uid2);
+          ctx.body = duplicated;
+          await next();
+        },
+        attach: async (ctx, next) => {
+          const { uid: uid2, parentId, subKey, subType, position } = ctx.action.params;
+          const repository = ctx.db.getRepository("flowModels");
+          const attached = await repository.attach(String(uid2 || "").trim(), {
+            parentId: String(parentId || "").trim(),
+            subKey: String(subKey || "").trim(),
+            subType,
+            position
+          });
+          ctx.body = attached;
+          await next();
+        },
         move: async (ctx, next) => {
           const { sourceId, targetId, position } = ctx.action.params;
           const repository = ctx.db.getRepository("flowModels");

package/dist/server/template/resolver.js

@@ -78,14 +78,18 @@ async function replacePlaceholders(input, ctx) {
 async function evaluate(expr, ctx) {
   try {
     const raw = expr.trim();
-    const dotOnly = raw.match(/^ctx\.([a-zA-Z_$][a-zA-Z0-9_$]*(?:\.[a-zA-Z_$][a-zA-Z0-9_$]*)*)$/);
+    const dotOnly = raw.match(
+      /^ctx\.([a-zA-Z_$][a-zA-Z0-9_$]*)(?:\.([a-zA-Z_$][a-zA-Z0-9_$-]*(?:\.[a-zA-Z_$][a-zA-Z0-9_$-]*)*))?$/
+    );
     if (dotOnly) {
-      const path = dotOnly[1];
-      const segs = path.split(".");
-      const first = segs.shift();
+      const first = dotOnly[1];
+      const rest = dotOnly[2];
       const base = await ctx[first];
-      if (!segs.length) return base;
-      return await asyncGetValuesByPath(base, segs.join("."));
+      if (!rest) return base;
+      const resolved = await asyncGetValuesByPath(base, rest);
+      if (typeof resolved !== "undefined" || !rest.includes("-")) {
+        return resolved;
+      }
     }
     const transformed = preprocessExpression(raw);
     const compartment = new Compartment({

package/dist/server/variables/records.d.ts

@@ -0,0 +1,38 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+type FilterTargetKey = string | string[] | undefined;
+/**
+ * 为了：
+ * - 关联加载/缓存：fields 模式下确保包含主键
+ * - filterByTk 为数组时：尽量包含 filterTargetKey，以便按输入顺序对齐结果
+ *
+ * 该函数只返回“建议追加”的 key 字段（不会决定是否追加，由调用方根据是否启用 fields 决定）。
+ */
+export declare function getExtraKeyFieldsForSelect(filterByTk: unknown, options: {
+    filterTargetKey?: FilterTargetKey;
+    pkAttr?: string;
+    pkIsValid?: boolean;
+    rawAttributes?: Record<string, unknown>;
+}): string[];
+export declare function mergeFieldsWithExtras(fields?: string[], extras?: string[]): string[] | undefined;
+/**
+ * 根据 filterByTk 类型（单值/数组）查询并返回 JSON 数据：
+ * - 单值：返回 object | undefined
+ * - 数组：返回 array（空数组时返回 []，不会退化为无条件查询）
+ */
+export declare function fetchRecordOrRecordsJson(repo: any, params: {
+    filterByTk: unknown;
+    preferFullRecord?: boolean;
+    fields?: string[];
+    appends?: string[];
+    filterTargetKey?: FilterTargetKey;
+    pkAttr?: string;
+    pkIsValid?: boolean;
+}): Promise<unknown>;
+export {};

package/dist/server/variables/records.js

@@ -0,0 +1,120 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var records_exports = {};
+__export(records_exports, {
+  fetchRecordOrRecordsJson: () => fetchRecordOrRecordsJson,
+  getExtraKeyFieldsForSelect: () => getExtraKeyFieldsForSelect,
+  mergeFieldsWithExtras: () => mergeFieldsWithExtras
+});
+module.exports = __toCommonJS(records_exports);
+function uniqStrings(list) {
+  return Array.from(new Set(list));
+}
+function isPrimitiveTkArray(arr) {
+  return arr.every((v) => typeof v === "string" || typeof v === "number");
+}
+function getOrderKey(options) {
+  if (typeof options.filterTargetKey === "string") return options.filterTargetKey;
+  if (options.pkIsValid && options.pkAttr) return options.pkAttr;
+  return void 0;
+}
+function getExtraKeyFieldsForSelect(filterByTk, options) {
+  const extra = [];
+  if (options.pkIsValid && options.pkAttr) {
+    extra.push(options.pkAttr);
+  }
+  if (Array.isArray(filterByTk) && filterByTk.length > 0) {
+    const tkKeys = typeof options.filterTargetKey === "string" ? [options.filterTargetKey] : Array.isArray(options.filterTargetKey) ? options.filterTargetKey : [];
+    if (options.rawAttributes) {
+      for (const k of tkKeys) {
+        if (k && Object.prototype.hasOwnProperty.call(options.rawAttributes, k)) {
+          extra.push(k);
+        }
+      }
+    }
+  }
+  return uniqStrings(extra);
+}
+function mergeFieldsWithExtras(fields, extras = []) {
+  if (!Array.isArray(fields) || fields.length === 0 || extras.length === 0) return fields;
+  return uniqStrings([...fields, ...extras]);
+}
+function toJsonArray(rows) {
+  if (!Array.isArray(rows)) return [];
+  return rows.map((r) => (r == null ? void 0 : r.toJSON) ? r.toJSON() : r);
+}
+function reorderRecordsByFilterByTk(records, filterByTk, options) {
+  if (!Array.isArray(filterByTk) || filterByTk.length === 0) return records;
+  if (!isPrimitiveTkArray(filterByTk)) return records;
+  const orderKey = getOrderKey(options);
+  if (!orderKey) return records;
+  const map = /* @__PURE__ */ new Map();
+  for (const rec of records || []) {
+    const k = rec == null ? void 0 : rec[orderKey];
+    if (typeof k !== "undefined" && k !== null) {
+      map.set(String(k), rec);
+    }
+  }
+  const ordered = [];
+  const used = /* @__PURE__ */ new Set();
+  for (const tk of filterByTk) {
+    const k = String(tk);
+    const rec = map.get(k);
+    if (typeof rec !== "undefined") {
+      ordered.push(rec);
+      used.add(k);
+    }
+  }
+  for (const rec of records || []) {
+    const k = rec == null ? void 0 : rec[orderKey];
+    const ks = typeof k === "undefined" || k === null ? void 0 : String(k);
+    if (!ks || used.has(ks)) continue;
+    ordered.push(rec);
+  }
+  return ordered;
+}
+async function fetchRecordOrRecordsJson(repo, params) {
+  const { filterByTk, preferFullRecord, fields, appends } = params;
+  if (Array.isArray(filterByTk)) {
+    if (filterByTk.length === 0) return [];
+    const rows = await repo.find(
+      preferFullRecord ? { filterByTk } : { filterByTk, fields, appends }
+    );
+    const jsonArr = toJsonArray(rows);
+    return reorderRecordsByFilterByTk(jsonArr, filterByTk, params);
+  }
+  const rec = await repo.findOne(
+    preferFullRecord ? { filterByTk } : { filterByTk, fields, appends }
+  );
+  return rec ? rec.toJSON() : void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  fetchRecordOrRecordsJson,
+  getExtraKeyFieldsForSelect,
+  mergeFieldsWithExtras
+});

package/dist/server/variables/registry.d.ts

@@ -39,4 +39,14 @@ declare class VariableRegistry {
     attachUsedVariables(ctx: HttpRequestContext, koaCtx: ResourcerContext, template: JSONValue, contextParams: any): Promise<void>;
 }
 export declare const variables: VariableRegistry;
+/** 仅测试使用：重置变量注册表为内置默认集 */
+/**
+ * 从使用路径推断查询所需的 fields 与 appends。
+ * @param paths 使用到的子路径数组
+ * @param params 显式参数（仅用于兼容签名）
+ */
+export declare function inferSelectsFromUsage(paths?: string[], _params?: unknown): {
+    generatedAppends?: string[];
+    generatedFields?: string[];
+};
 export {};