@nocobase/plugin-flow-engine 3.0.0-alpha.5 → 3.0.0-alpha.7

package/dist/server/variables/record-slot-policy.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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.
+ */
+import type { Application } from '@nocobase/server';
+import type { AnalyzedTemplate } from '../template/variable-expression';
+import { type RecordSlotResolved, type RecordSlotResolverInput, type RecordSlotResolverRegistration } from './record-slot-resolvers';
+export type RecordSlotPolicy = RecordSlotResolved;
+export type RecordSlotPolicies = ReadonlyMap<string, RecordSlotPolicy>;
+export type FlowModelVariableContract = Readonly<{
+    allowedPaths: ReadonlySet<string>;
+    recordSlots: RecordSlotPolicies;
+}>;
+export type CompileRecordSlotPoliciesOptions = Omit<RecordSlotResolverInput, 'path'> & Readonly<{
+    app: Application;
+}>;
+export declare function createBuiltInRecordSlotResolvers(): readonly RecordSlotResolverRegistration[];
+export declare function compileRecordSlotPolicies(analysis: Pick<AnalyzedTemplate, 'paths'>, options: CompileRecordSlotPoliciesOptions): Promise<RecordSlotPolicies>;
+export declare function createFlowModelVariableContract(analysis: AnalyzedTemplate, options: CompileRecordSlotPoliciesOptions): Promise<FlowModelVariableContract>;

package/dist/server/variables/record-slot-policy.js

@@ -0,0 +1,100 @@
+/**
+ * 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 record_slot_policy_exports = {};
+__export(record_slot_policy_exports, {
+  compileRecordSlotPolicies: () => compileRecordSlotPolicies,
+  createBuiltInRecordSlotResolvers: () => createBuiltInRecordSlotResolvers,
+  createFlowModelVariableContract: () => createFlowModelVariableContract
+});
+module.exports = __toCommonJS(record_slot_policy_exports);
+var import_record_slot_resolvers = require("./record-slot-resolvers");
+function resolved(slot) {
+  return { status: "resolved", slot };
+}
+function createBuiltInRecordSlotResolvers() {
+  return [
+    ...["record", "responseRecord", "clickedRowRecord"].map(
+      (varName) => ({
+        owner: "@nocobase/plugin-flow-engine",
+        id: `direct:${varName}`,
+        match: (path) => path.varName === varName,
+        resolve: () => resolved([])
+      })
+    ),
+    {
+      owner: "@nocobase/plugin-flow-engine",
+      id: "view:record",
+      match: (path) => path.varName === "view" && path.runtimeSegments[0] === "record",
+      resolve: () => resolved(["record"])
+    },
+    {
+      owner: "@nocobase/plugin-flow-engine",
+      id: "popup:record",
+      match: (path) => {
+        if (path.varName !== "popup") return false;
+        let index = 0;
+        while (path.runtimeSegments[index] === "parent") index += 1;
+        return path.runtimeSegments[index] === "record" || path.runtimeSegments[index] === "sourceRecord";
+      },
+      resolve: ({ path }) => {
+        let index = 0;
+        while (path.runtimeSegments[index] === "parent") index += 1;
+        return resolved(path.runtimeSegments.slice(0, index + 1));
+      }
+    }
+  ];
+}
+function samePolicy(left, right) {
+  return left.slot.length === right.slot.length && left.slot.every((segment, index) => segment === right.slot[index]);
+}
+async function compileRecordSlotPolicies(analysis, options) {
+  const registry = (0, import_record_slot_resolvers.getRecordSlotResolverRegistry)(options.app);
+  const occurrences = /* @__PURE__ */ new Map();
+  for (const path of analysis.paths) {
+    const policies = occurrences.get(path.canonicalKey) || [];
+    policies.push(await registry.resolve({ ...options, path }));
+    occurrences.set(path.canonicalKey, policies);
+  }
+  const result = /* @__PURE__ */ new Map();
+  for (const [canonicalKey, policies] of occurrences) {
+    const first = policies[0];
+    if (first && policies.every((policy) => !!policy && samePolicy(policy, first))) result.set(canonicalKey, first);
+  }
+  return result;
+}
+async function createFlowModelVariableContract(analysis, options) {
+  return Object.freeze({
+    allowedPaths: new Set(analysis.paths.map((path) => path.canonicalKey)),
+    recordSlots: await compileRecordSlotPolicies(analysis, options)
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  compileRecordSlotPolicies,
+  createBuiltInRecordSlotResolvers,
+  createFlowModelVariableContract
+});

package/dist/server/variables/record-slot-resolvers.d.ts

@@ -0,0 +1,46 @@
+/**
+ * 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.
+ */
+import type { ResourcerContext } from '@nocobase/resourcer';
+import type { Application } from '@nocobase/server';
+import type { PathSegment, VariablePathRef } from '../template/variable-expression';
+type MaybePromise<T> = T | Promise<T>;
+export type RecordSlotResolved = Readonly<{
+    status: 'resolved';
+    slot: readonly PathSegment[];
+}>;
+export type RecordSlotResolverResult = RecordSlotResolved | Readonly<{
+    status: 'deny' | 'abstain';
+}>;
+export type RecordSlotResolverInput = Readonly<{
+    path: VariablePathRef;
+    currentNode?: unknown;
+    loadAncestors?: () => Promise<readonly unknown[]>;
+    ctx?: ResourcerContext;
+    getCollection?: (dataSourceKey: string, collection: string) => unknown;
+}>;
+export type RecordSlotResolverRegistration = Readonly<{
+    owner: string;
+    id: string;
+    needsAncestors?: boolean;
+    match: (path: VariablePathRef) => boolean;
+    resolve: (input: RecordSlotResolverInput) => MaybePromise<RecordSlotResolverResult>;
+}>;
+export declare class RecordSlotResolverRegistry {
+    private readonly registrations;
+    has(owner: string, id: string): boolean;
+    register(registration: RecordSlotResolverRegistration): () => void;
+    resolve(input: RecordSlotResolverInput): Promise<RecordSlotResolved | undefined>;
+}
+export declare function getRecordSlotResolverRegistry(app: Application): RecordSlotResolverRegistry;
+export declare function createNestedRecordSlotResolver(registration: Readonly<{
+    owner: string;
+    id: string;
+    varName: string;
+}>): RecordSlotResolverRegistration;
+export {};

package/dist/server/variables/record-slot-resolvers.js

@@ -0,0 +1,115 @@
+/**
+ * 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 record_slot_resolvers_exports = {};
+__export(record_slot_resolvers_exports, {
+  RecordSlotResolverRegistry: () => RecordSlotResolverRegistry,
+  createNestedRecordSlotResolver: () => createNestedRecordSlotResolver,
+  getRecordSlotResolverRegistry: () => getRecordSlotResolverRegistry
+});
+module.exports = __toCommonJS(record_slot_resolvers_exports);
+function normalizeResolved(result) {
+  if (result.status !== "resolved" || !Array.isArray(result.slot)) return void 0;
+  if (result.slot.some(
+    (segment) => typeof segment !== "string" && typeof segment !== "number" || typeof segment === "string" && segment.includes("*") || typeof segment === "number" && (!Number.isSafeInteger(segment) || segment < 0)
+  )) {
+    return void 0;
+  }
+  return Object.freeze({ status: "resolved", slot: Object.freeze([...result.slot]) });
+}
+function sameResolved(left, right) {
+  return left.slot.length === right.slot.length && left.slot.every((segment, index) => segment === right.slot[index]);
+}
+class RecordSlotResolverRegistry {
+  registrations = /* @__PURE__ */ new Map();
+  has(owner, id) {
+    var _a;
+    return ((_a = this.registrations.get(owner.trim())) == null ? void 0 : _a.has(id.trim())) === true;
+  }
+  register(registration) {
+    const owner = registration.owner.trim();
+    const id = registration.id.trim();
+    if (!owner || !id) throw new TypeError("Record Slot resolver owner and id are required");
+    const entry = Object.freeze({ ...registration, owner, id });
+    let owned = this.registrations.get(owner);
+    if (!owned) {
+      owned = /* @__PURE__ */ new Map();
+      this.registrations.set(owner, owned);
+    }
+    owned.set(id, entry);
+    return () => {
+      const current = this.registrations.get(owner);
+      if ((current == null ? void 0 : current.get(id)) !== entry) return;
+      current.delete(id);
+      if (!current.size) this.registrations.delete(owner);
+    };
+  }
+  async resolve(input) {
+    const resolutions = [];
+    for (const owned of this.registrations.values()) {
+      for (const registration of owned.values()) {
+        try {
+          if (!registration.match(input.path)) continue;
+          const result = await registration.resolve(
+            registration.needsAncestors ? input : { ...input, loadAncestors: void 0 }
+          );
+          if (result.status === "deny") return void 0;
+          if (result.status === "abstain") continue;
+          const normalized = normalizeResolved(result);
+          if (!normalized) return void 0;
+          resolutions.push(normalized);
+        } catch (_) {
+          return void 0;
+        }
+      }
+    }
+    const first = resolutions[0];
+    return first && resolutions.every((resolution) => sameResolved(resolution, first)) ? first : void 0;
+  }
+}
+const registries = /* @__PURE__ */ new WeakMap();
+function getRecordSlotResolverRegistry(app) {
+  let registry = registries.get(app);
+  if (!registry) {
+    registry = new RecordSlotResolverRegistry();
+    registries.set(app, registry);
+  }
+  return registry;
+}
+function createNestedRecordSlotResolver(registration) {
+  return Object.freeze({
+    owner: registration.owner,
+    id: registration.id,
+    match: (path) => path.varName === registration.varName && path.runtimeSegments[0] === "record",
+    resolve: () => ({ status: "resolved", slot: ["record"] })
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RecordSlotResolverRegistry,
+  createNestedRecordSlotResolver,
+  getRecordSlotResolverRegistry
+});

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

@@ -6,7 +6,53 @@
  * 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 type { Collection, RelationRepository, Repository } from '@nocobase/database';
+import type { ResourcerContext } from '@nocobase/resourcer';
 type FilterTargetKey = string | string[] | undefined;
+type RecordRepository = Repository | RelationRepository;
+export type RecordParams = {
+    associationName?: string;
+    collection: string;
+    dataSourceKey?: string;
+    filterByTk: unknown;
+    sourceId?: unknown;
+    fields?: string[];
+    appends?: string[];
+};
+export type RecordTarget = {
+    repository: RecordRepository;
+    dataSourceKey: string;
+    collection: Collection;
+    collectionName: string;
+    filterTargetKey: FilterTargetKey;
+    pkAttr?: string;
+    pkIsValid: boolean;
+    rawAttributes?: Record<string, unknown>;
+    cacheIdentity: Readonly<{
+        ds: string;
+        c: string;
+        assoc?: string;
+        sid?: unknown;
+    }>;
+};
+export type RecordQuery = RecordTarget & {
+    filterByTk: unknown;
+    fields?: string[];
+    appends?: string[];
+    preferFullRecord: boolean;
+    strictSelects: boolean;
+    cacheKey: string;
+};
+export declare function isRecordParams(value: unknown): value is RecordParams;
+export declare function resolveRecordTarget(koaCtx: ResourcerContext, params: RecordParams): RecordTarget | undefined;
+export declare function prepareRecordQuery(koaCtx: ResourcerContext, target: RecordTarget, filterByTk: unknown, fields?: string[], appends?: string[], strictSelects?: boolean, preferFullRecord?: boolean): RecordQuery;
+export declare function getRecordRequestCache(koaCtx: ResourcerContext): Map<string, unknown>;
+export declare function setRecordRequestCache(cache: Map<string, unknown>, query: RecordQuery, value: unknown): Map<string, unknown>;
+export declare function findRecordRequestCacheValue(cache: Map<string, unknown>, query: RecordQuery): {
+    hit: boolean;
+    value: unknown;
+};
+export declare function fetchRecordWithRequestCache(koaCtx: ResourcerContext, params: RecordParams, fields?: string[], appends?: string[], strictSelects?: boolean, preferFullRecord?: boolean): Promise<unknown>;
 /**
  * 为了：
  * - 关联加载/缓存：fields 模式下确保包含主键
@@ -26,7 +72,7 @@ export declare function mergeFieldsWithExtras(fields?: string[], extras?: string
  * - 单值：返回 object | undefined
  * - 数组：返回 array（空数组时返回 []，不会退化为无条件查询）
  */
-export declare function fetchRecordOrRecordsJson(repo: any, params: {
+export declare function fetchRecordOrRecordsJson(repo: RecordRepository, params: {
     filterByTk: unknown;
     preferFullRecord?: boolean;
     fields?: string[];

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,279 @@ 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;
+  const dataSourceKey = params.dataSourceKey || "main";
+  const usesAssociation = !!(params.associationName && typeof params.sourceId !== "undefined");
+  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;
+  if (!(cm == null ? void 0 : cm.db)) {
+    targets.set(requestKey, void 0);
+    return void 0;
+  }
+  const 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 collection = "targetCollection" in repository && repository.targetCollection || repository.collection || cm.db.getCollection(params.associationName || params.collection);
+  if (!collection) {
+    targets.set(requestKey, void 0);
+    return void 0;
+  }
+  if (usesAssociation && collection.name !== params.collection) {
+    targets.set(requestKey, void 0);
+    return void 0;
+  }
+  const rawAttributes = (_a = collection.model) == null ? void 0 : _a.rawAttributes;
+  const pkAttr = (_b = collection.model) == null ? void 0 : _b.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);
+    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));
 }
@@ -60,7 +327,7 @@ function getExtraKeyFieldsForSelect(filterByTk, options) {
   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) {
@@ -79,7 +346,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,7 +362,7 @@ 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);
@@ -120,6 +387,13 @@ async function fetchRecordOrRecordsJson(repo, params) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   fetchRecordOrRecordsJson,
+  fetchRecordWithRequestCache,
+  findRecordRequestCacheValue,
   getExtraKeyFieldsForSelect,
-  mergeFieldsWithExtras
+  getRecordRequestCache,
+  isRecordParams,
+  mergeFieldsWithExtras,
+  prepareRecordQuery,
+  resolveRecordTarget,
+  setRecordRequestCache
 });