@nocobase/plugin-flow-engine 2.3.0-alpha.1 → 2.3.0-beta.10

package/dist/server/variables/records.js

@@ -7,9 +7,11 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -23,14 +25,285 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var records_exports = {};
 __export(records_exports, {
   fetchRecordOrRecordsJson: () => fetchRecordOrRecordsJson,
+  fetchRecordWithRequestCache: () => fetchRecordWithRequestCache,
+  findRecordRequestCacheValue: () => findRecordRequestCacheValue,
   getExtraKeyFieldsForSelect: () => getExtraKeyFieldsForSelect,
-  mergeFieldsWithExtras: () => mergeFieldsWithExtras
+  getRecordRequestCache: () => getRecordRequestCache,
+  isRecordParams: () => isRecordParams,
+  mergeFieldsWithExtras: () => mergeFieldsWithExtras,
+  prepareRecordQuery: () => prepareRecordQuery,
+  resolveRecordTarget: () => resolveRecordTarget,
+  setRecordRequestCache: () => setRecordRequestCache
 });
 module.exports = __toCommonJS(records_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_selects = require("./selects");
+function sortIdentityValue(value) {
+  if (Array.isArray(value)) return value.map(sortIdentityValue);
+  if (!import_lodash.default.isPlainObject(value)) return value;
+  return Object.fromEntries(
+    Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, child]) => [key, sortIdentityValue(child)])
+  );
+}
+function getBaseIdentityKey(identity) {
+  return JSON.stringify(sortIdentityValue(identity));
+}
+function createCacheMetadata(query) {
+  const cacheIdentity = {
+    ds: query.ds,
+    c: query.c,
+    assoc: query.assoc,
+    sid: query.sid,
+    tk: query.tk
+  };
+  return {
+    appends: query.a ? new Set(query.a) : void 0,
+    baseIdentityKey: getBaseIdentityKey(cacheIdentity),
+    cacheIdentity,
+    fields: query.f ? new Set(query.f) : void 0,
+    full: query.full === true
+  };
+}
+class RecordRequestCache extends Map {
+  keysByBaseIdentity = /* @__PURE__ */ new Map();
+  metadataByKey = /* @__PURE__ */ new Map();
+  constructor(entries) {
+    super();
+    entries == null ? void 0 : entries.forEach((value, key) => this.set(key, value));
+  }
+  set(cacheKey, value) {
+    let metadata;
+    try {
+      metadata = createCacheMetadata(JSON.parse(cacheKey));
+    } catch (_2) {
+    }
+    return this.setWithMetadata(cacheKey, value, metadata);
+  }
+  setQuery(query, value) {
+    return this.setWithMetadata(
+      query.cacheKey,
+      value,
+      createCacheMetadata({
+        ...query.cacheIdentity,
+        tk: query.filterByTk,
+        f: query.fields,
+        a: query.appends,
+        full: query.preferFullRecord
+      })
+    );
+  }
+  delete(cacheKey) {
+    this.removeFromIndex(cacheKey);
+    return super.delete(cacheKey);
+  }
+  clear() {
+    super.clear();
+    this.keysByBaseIdentity.clear();
+    this.metadataByKey.clear();
+  }
+  *candidates(query) {
+    const baseIdentityKey = getBaseIdentityKey({
+      ...query.cacheIdentity,
+      tk: query.filterByTk
+    });
+    for (const cacheKey of this.keysByBaseIdentity.get(baseIdentityKey) || []) {
+      const metadata = this.metadataByKey.get(cacheKey);
+      if (metadata && super.has(cacheKey)) yield [metadata, super.get(cacheKey)];
+    }
+  }
+  setWithMetadata(cacheKey, value, metadata) {
+    this.removeFromIndex(cacheKey);
+    super.set(cacheKey, value);
+    if (!metadata) return this;
+    this.metadataByKey.set(cacheKey, metadata);
+    let keys = this.keysByBaseIdentity.get(metadata.baseIdentityKey);
+    if (!keys) {
+      keys = /* @__PURE__ */ new Set();
+      this.keysByBaseIdentity.set(metadata.baseIdentityKey, keys);
+    }
+    keys.add(cacheKey);
+    return this;
+  }
+  removeFromIndex(cacheKey) {
+    const metadata = this.metadataByKey.get(cacheKey);
+    if (!metadata) return;
+    const keys = this.keysByBaseIdentity.get(metadata.baseIdentityKey);
+    keys == null ? void 0 : keys.delete(cacheKey);
+    if (!(keys == null ? void 0 : keys.size)) this.keysByBaseIdentity.delete(metadata.baseIdentityKey);
+    this.metadataByKey.delete(cacheKey);
+  }
+}
+function isRecordParams(value) {
+  return !!value && typeof value === "object" && typeof value.collection === "string" && Object.prototype.hasOwnProperty.call(value, "filterByTk");
+}
+function resolveRecordTarget(koaCtx, params) {
+  var _a, _b, _c, _d, _e, _f;
+  const dataSourceKey = params.dataSourceKey || "main";
+  const usesAssociation = !!(params.associationName && typeof params.sourceId !== "undefined");
+  const associationSourceCollection = usesAssociation ? (_a = params.associationName) == null ? void 0 : _a.split(".")[0] : void 0;
+  const context = koaCtx;
+  if (!context.state) context.state = {};
+  const targets = context.state.__varResolveRecordTargets ??= /* @__PURE__ */ new Map();
+  const requestKey = JSON.stringify({
+    ds: dataSourceKey,
+    c: params.collection,
+    assoc: usesAssociation ? params.associationName : void 0,
+    sid: usesAssociation ? params.sourceId : void 0
+  });
+  if (targets.has(requestKey)) return targets.get(requestKey);
+  const ds = koaCtx.app.dataSourceManager.get(dataSourceKey);
+  const cm = ds.collectionManager;
+  let repository;
+  if (typeof cm.getRepository === "function") {
+    repository = usesAssociation ? cm.getRepository(params.associationName, params.sourceId) : cm.getRepository(params.collection);
+  } else if (typeof ((_b = cm.db) == null ? void 0 : _b.getRepository) === "function") {
+    repository = usesAssociation ? cm.db.getRepository(params.associationName, params.sourceId) : cm.db.getRepository(params.collection);
+  }
+  if (!repository) {
+    targets.set(requestKey, void 0);
+    return void 0;
+  }
+  const repositoryMetadata = repository;
+  let collection = repositoryMetadata.targetCollection || repositoryMetadata.collection;
+  if (!usesAssociation && !collection) {
+    collection = (typeof cm.getCollection === "function" ? cm.getCollection(params.collection) : (_d = (_c = cm.db) == null ? void 0 : _c.getCollection) == null ? void 0 : _d.call(_c, params.collection)) || { name: params.collection };
+  }
+  if (!collection) {
+    targets.set(requestKey, void 0);
+    return void 0;
+  }
+  if (usesAssociation && (!collection.name || collection.name !== params.collection && associationSourceCollection !== params.collection)) {
+    targets.set(requestKey, void 0);
+    return void 0;
+  }
+  const rawAttributes = (_e = collection.model) == null ? void 0 : _e.rawAttributes;
+  const pkAttr = (_f = collection.model) == null ? void 0 : _f.primaryKeyAttribute;
+  const pkIsValid = !!(pkAttr && rawAttributes && Object.prototype.hasOwnProperty.call(rawAttributes, pkAttr));
+  const collectionName = collection.name || params.associationName || params.collection;
+  const target = {
+    repository,
+    dataSourceKey,
+    collection,
+    collectionName,
+    filterTargetKey: collection.filterTargetKey,
+    pkAttr,
+    pkIsValid,
+    rawAttributes,
+    cacheIdentity: {
+      ds: dataSourceKey,
+      c: collectionName,
+      assoc: usesAssociation ? params.associationName : void 0,
+      sid: usesAssociation ? params.sourceId : void 0
+    }
+  };
+  targets.set(requestKey, target);
+  return target;
+}
+function prepareRecordQuery(koaCtx, target, filterByTk, fields, appends, strictSelects = false, preferFullRecord = false) {
+  var _a;
+  const adjusted = (0, import_selects.adjustSelectsForCollection)(koaCtx, target.dataSourceKey, target.collectionName, fields, appends);
+  const extraKeys = getExtraKeyFieldsForSelect(filterByTk, target);
+  const selectedFields = mergeFieldsWithExtras(
+    strictSelects && Array.isArray(fields) ? adjusted.fields || [] : adjusted.fields,
+    extraKeys
+  );
+  const queryFields = preferFullRecord ? void 0 : selectedFields == null ? void 0 : selectedFields.slice().sort();
+  const queryAppends = preferFullRecord ? void 0 : (_a = adjusted.appends) == null ? void 0 : _a.slice().sort();
+  const cacheKey = JSON.stringify({
+    ...target.cacheIdentity,
+    tk: filterByTk,
+    f: queryFields,
+    a: queryAppends,
+    full: preferFullRecord || void 0,
+    strict: strictSelects || void 0
+  });
+  return {
+    ...target,
+    filterByTk,
+    fields: queryFields,
+    appends: queryAppends,
+    preferFullRecord,
+    strictSelects,
+    cacheKey
+  };
+}
+function getRecordRequestCache(koaCtx) {
+  const context = koaCtx;
+  if (!context.state) context.state = {};
+  const existing = context.state.__varResolveBatchCache;
+  if (existing instanceof RecordRequestCache) return existing;
+  const cache = new RecordRequestCache(existing instanceof Map ? existing : void 0);
+  context.state.__varResolveBatchCache = cache;
+  return cache;
+}
+function setRecordRequestCache(cache, query, value) {
+  if (cache instanceof RecordRequestCache) return cache.setQuery(query, value);
+  return cache.set(query.cacheKey, value);
+}
+function cachedQueryCovers(query, cached) {
+  if (cached.cacheIdentity.ds !== query.cacheIdentity.ds || cached.cacheIdentity.c !== query.cacheIdentity.c || cached.cacheIdentity.assoc !== query.cacheIdentity.assoc || !import_lodash.default.isEqual(cached.cacheIdentity.sid, query.cacheIdentity.sid) || !import_lodash.default.isEqual(cached.cacheIdentity.tk, query.filterByTk)) {
+    return false;
+  }
+  if (cached.full) return true;
+  if (query.preferFullRecord) return false;
+  const cachedFields = cached.fields || /* @__PURE__ */ new Set();
+  const cachedAppends = cached.appends || /* @__PURE__ */ new Set();
+  const fieldCovered = (field) => cachedFields.has(field) || [...cachedAppends].some((append) => field === append || field.startsWith(`${append}.`));
+  return (query.fields ? query.fields.every(fieldCovered) : cached.fields === void 0) && (!query.appends || query.appends.every((append) => cachedAppends.has(append)));
+}
+function findRecordRequestCacheValue(cache, query) {
+  if (cache.has(query.cacheKey)) return { hit: true, value: cache.get(query.cacheKey) };
+  if (cache instanceof RecordRequestCache) {
+    for (const [metadata, value] of cache.candidates(query)) {
+      if (cachedQueryCovers(query, metadata)) return { hit: true, value };
+    }
+  }
+  return { hit: false, value: void 0 };
+}
+async function fetchRecordWithRequestCache(koaCtx, params, fields, appends, strictSelects = false, preferFullRecord = false) {
+  var _a, _b, _c;
+  try {
+    const target = resolveRecordTarget(koaCtx, params);
+    if (!target) return void 0;
+    const query = prepareRecordQuery(
+      koaCtx,
+      target,
+      params.filterByTk,
+      fields,
+      appends,
+      strictSelects,
+      preferFullRecord
+    );
+    const cache = getRecordRequestCache(koaCtx);
+    const cached = findRecordRequestCacheValue(cache, query);
+    if (cached.hit) return cached.value;
+    const value = await fetchRecordOrRecordsJson(query.repository, query, koaCtx);
+    setRecordRequestCache(cache, query, value);
+    return value;
+  } catch (error) {
+    (_c = (_b = (_a = koaCtx.app) == null ? void 0 : _a.logger) == null ? void 0 : _b.child({ module: "plugin-flow-engine", submodule: "variables.resolve", method: "fetchRecordWithRequestCache" })) == null ? void 0 : _c.warn("[variables.resolve] fetchRecordWithRequestCache error", {
+      ds: params.dataSourceKey || "main",
+      collection: params.collection,
+      tk: params.filterByTk,
+      fields,
+      appends,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return void 0;
+  }
+}
 function uniqStrings(list) {
   return Array.from(new Set(list));
 }
@@ -49,18 +322,16 @@ function getExtraKeyFieldsForSelect(filterByTk, options) {
   }
   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);
-        }
+    for (const k of tkKeys) {
+      if (k && (!options.rawAttributes || 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;
+  if (!Array.isArray(fields) || extras.length === 0) return fields;
   return uniqStrings([...fields, ...extras]);
 }
 function toJsonRecord(record) {
@@ -72,6 +343,20 @@ function toJsonArray(rows) {
   if (!Array.isArray(rows)) return [];
   return rows.map(toJsonRecord);
 }
+function createRecordRepositoryContext(context, params) {
+  var _a;
+  if (!((_a = context.action) == null ? void 0 : _a.params)) return context;
+  const repositoryContext = Object.create(context);
+  const repositoryAction = Object.create(context.action);
+  repositoryAction.params = {
+    ...context.action.params,
+    filterByTk: params.filterByTk,
+    fields: params.fields,
+    appends: params.appends
+  };
+  repositoryContext.action = repositoryAction;
+  return repositoryContext;
+}
 function reorderRecordsByFilterByTk(records, filterByTk, options) {
   if (!Array.isArray(filterByTk) || filterByTk.length === 0) return records;
   if (!isPrimitiveTkArray(filterByTk)) return records;
@@ -79,7 +364,7 @@ function reorderRecordsByFilterByTk(records, filterByTk, options) {
   if (!orderKey) return records;
   const map = /* @__PURE__ */ new Map();
   for (const rec of records || []) {
-    const k = rec == null ? void 0 : rec[orderKey];
+    const k = rec && typeof rec === "object" ? rec[orderKey] : void 0;
     if (typeof k !== "undefined" && k !== null) {
       map.set(String(k), rec);
     }
@@ -95,31 +380,37 @@ function reorderRecordsByFilterByTk(records, filterByTk, options) {
     }
   }
   for (const rec of records || []) {
-    const k = rec == null ? void 0 : rec[orderKey];
+    const k = rec && typeof rec === "object" ? rec[orderKey] : void 0;
     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) {
+async function fetchRecordOrRecordsJson(repo, params, context) {
   const { filterByTk, preferFullRecord, fields, appends } = params;
+  if (Array.isArray(filterByTk) && filterByTk.length === 0) return [];
+  const query = preferFullRecord ? { filterByTk } : { filterByTk, fields, appends };
+  const repositoryContext = createRecordRepositoryContext(context, query);
+  const repositoryOptions = { ...query, context: repositoryContext };
   if (Array.isArray(filterByTk)) {
-    if (filterByTk.length === 0) return [];
-    const rows = await repo.find(
-      preferFullRecord ? { filterByTk } : { filterByTk, fields, appends }
-    );
+    const rows = await repo.find(repositoryOptions);
     const jsonArr = toJsonArray(rows);
     return reorderRecordsByFilterByTk(jsonArr, filterByTk, params);
   }
-  const rec = await repo.findOne(
-    preferFullRecord ? { filterByTk } : { filterByTk, fields, appends }
-  );
+  const rec = await repo.findOne(repositoryOptions);
   return rec ? toJsonRecord(rec) : void 0;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   fetchRecordOrRecordsJson,
+  fetchRecordWithRequestCache,
+  findRecordRequestCacheValue,
   getExtraKeyFieldsForSelect,
-  mergeFieldsWithExtras
+  getRecordRequestCache,
+  isRecordParams,
+  mergeFieldsWithExtras,
+  prepareRecordQuery,
+  resolveRecordTarget,
+  setRecordRequestCache
 });

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

@@ -6,8 +6,10 @@
  * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
-import { HttpRequestContext } from '../template/contexts';
 import { ResourcerContext } from '@nocobase/resourcer';
+import { HttpRequestContext } from '../template/contexts';
+import { type PathSegment, type VariablePathRef } from '../template/variable-expression';
+import { type AuthorizedRecordBinding, type RecordBindingPlan } from './record-bindings';
 export type JSONValue = string | {
     [key: string]: JSONValue;
 } | JSONValue[];
@@ -15,38 +17,59 @@ export type VarScope = 'global' | 'request';
 export interface RequiredParamSpec {
     name: string;
     required?: boolean;
-    defaultValue?: any;
+    defaultValue?: unknown;
 }
+export type ValidateContextParamsOptions = {
+    contextParams: Record<string, unknown>;
+    flowModelUid?: string;
+    koaCtx: ResourcerContext;
+    usage: readonly VariablePathRef[];
+    varName: string;
+};
+export type ValidateContextParamsResult = {
+    allowed?: boolean;
+    contextParams?: Record<string, unknown>;
+    requireFlowModel?: boolean;
+};
 export interface VariableDef {
     name: string;
     scope: VarScope;
     requiredParams?: RequiredParamSpec[];
-    attach: (ctx: HttpRequestContext, koaCtx: ResourcerContext, params?: any, usage?: VarUsage) => Promise<void> | void;
+    attach: (ctx: HttpRequestContext, koaCtx: ResourcerContext, params?: unknown, usage?: VarUsage) => Promise<void> | void;
+    validateContextParams?: (options: ValidateContextParamsOptions) => Promise<ValidateContextParamsResult | void> | ValidateContextParamsResult | void;
 }
-export type VarUsage = {
-    [varName: string]: string[];
-};
+export type VarUsage = Readonly<Record<string, readonly VariablePathRef[]>>;
+type LegacyVarUsage = Record<string, string[]>;
 declare class VariableRegistry {
     private vars;
     register(def: VariableDef): void;
     get(name: string): VariableDef;
     list(): VariableDef[];
-    extractUsage(template: JSONValue): VarUsage;
-    validate(template: JSONValue, contextParams: any): {
+    extractUsage(template: JSONValue): LegacyVarUsage;
+    validate(template: JSONValue, contextParams: unknown): {
         ok: boolean;
         missing?: string[];
     };
-    attachUsedVariables(ctx: HttpRequestContext, koaCtx: ResourcerContext, template: JSONValue, contextParams: any): Promise<void>;
+    attachUsedVariables(ctx: HttpRequestContext, koaCtx: ResourcerContext, template: JSONValue, contextParams: Record<string, unknown>): Promise<void>;
+    attachUsedVariablesFromUsage(ctx: HttpRequestContext, koaCtx: ResourcerContext, usage: VarUsage, contextParams: Record<string, unknown>): Promise<void>;
+    attachUsedVariablesFromPlan(ctx: HttpRequestContext, koaCtx: ResourcerContext, usage: VarUsage, plan: RecordBindingPlan): Promise<void>;
 }
 export declare const variables: VariableRegistry;
 /** 仅测试使用：重置变量注册表为内置默认集 */
+export declare function omitVariableContextParams(contextParams: Record<string, unknown>, varName: string): Record<string, unknown>;
+export declare function sanitizeRegisteredVariableContextParams(contextParams: Record<string, unknown>, registry?: {
+    get?: (name: string) => VariableDef | undefined;
+    list?: () => VariableDef[];
+}): Record<string, unknown>;
 /**
  * 从使用路径推断查询所需的 fields 与 appends。
  * @param paths 使用到的子路径数组
  * @param params 显式参数（仅用于兼容签名）
  */
-export declare function inferSelectsFromUsage(paths?: string[], _params?: unknown): {
+export declare function inferSelectsFromUsage(paths?: readonly (string | readonly PathSegment[])[], _params?: unknown): {
     generatedAppends?: string[];
     generatedFields?: string[];
 };
+export declare function isSafeRecordBinding(binding: AuthorizedRecordBinding): boolean;
+export declare function registerBuiltInVariables(reg: VariableRegistry): void;
 export {};