@nocobase/plugin-flow-engine 3.0.0-alpha.6 → 3.0.0-alpha.8

package/dist/server/variables/registry.js

@@ -37,14 +37,22 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var registry_exports = {};
 __export(registry_exports, {
   inferSelectsFromUsage: () => inferSelectsFromUsage,
+  isSafeRecordBinding: () => isSafeRecordBinding,
+  omitVariableContextParams: () => omitVariableContextParams,
+  registerBuiltInVariables: () => registerBuiltInVariables,
+  sanitizeRegisteredVariableContextParams: () => sanitizeRegisteredVariableContextParams,
   variables: () => variables
 });
 module.exports = __toCommonJS(registry_exports);
 var import_lodash = __toESM(require("lodash"));
-var import_contexts = require("../template/contexts");
 var import_utils = require("@nocobase/utils");
-var import_selects = require("./selects");
+var import_context_keys = require("../template/context-keys");
+var import_contexts = require("../template/contexts");
+var import_variable_expression = require("../template/variable-expression");
+var import_record_bindings = require("./record-bindings");
+var import_record_projection = require("./record-projection");
 var import_records = require("./records");
+var import_record_slot_policy = require("./record-slot-policy");
 class VariableRegistry {
   vars = /* @__PURE__ */ new Map();
   register(def) {
@@ -76,15 +84,31 @@ class VariableRegistry {
     return { ok: missing.length === 0, missing: missing.length ? missing : void 0 };
   }
   async attachUsedVariables(ctx, koaCtx, template, contextParams) {
-    const usage = this.extractUsage(template);
+    const usage = (0, import_variable_expression.analyzeVariableTemplate)(template).usage;
+    return this.attachUsedVariablesFromUsage(ctx, koaCtx, usage, contextParams);
+  }
+  async attachUsedVariablesFromUsage(ctx, koaCtx, usage, contextParams) {
+    const policies = await (0, import_record_slot_policy.compileRecordSlotPolicies)(
+      { paths: Object.values(usage).flat() },
+      { app: koaCtx.app, ctx: koaCtx }
+    );
+    const plan = (0, import_record_bindings.planRecordBindings)({
+      contextParams,
+      koaCtx,
+      policies,
+      usage
+    });
+    return this.attachUsedVariablesFromPlan(ctx, koaCtx, usage, await plan);
+  }
+  async attachUsedVariablesFromPlan(ctx, koaCtx, usage, plan) {
     for (const varName of Object.keys(usage)) {
       const def = this.get(varName);
-      const params = import_lodash.default.get(contextParams, varName);
+      const params = import_lodash.default.get(plan.contextParams, varName);
       if (def) {
         await def.attach(ctx, koaCtx, params, { [varName]: usage[varName] });
       }
     }
-    attachGenericRecordVariables(ctx, koaCtx, usage, contextParams);
+    attachAuthorizedRecordBindings(ctx, koaCtx, plan.bindings);
   }
 }
 const GLOBAL_KEY = "__ncbVarRegistry__";
@@ -96,6 +120,29 @@ if (!g[GLOBAL_KEY]) {
   g[GLOBAL_KEY] = new VariableRegistry();
 }
 const variables = g[GLOBAL_KEY];
+function omitVariableContextParams(contextParams, varName) {
+  if (!contextParams || typeof contextParams !== "object") return {};
+  const prefix = `${varName}.`;
+  const next = {};
+  for (const [key, value] of Object.entries(contextParams)) {
+    if (key === varName || key.startsWith(prefix)) continue;
+    next[key] = value;
+  }
+  return next;
+}
+function sanitizeRegisteredVariableContextParams(contextParams, registry = variables) {
+  let next = contextParams;
+  const defs = typeof registry.list === "function" ? registry.list() : ["user"].map((name) => {
+    var _a;
+    return (_a = registry.get) == null ? void 0 : _a.call(registry, name);
+  }).filter((def) => !!def);
+  for (const def of defs) {
+    if (def.name === "user") {
+      next = omitVariableContextParams(next, def.name);
+    }
+  }
+  return next;
+}
 function inferSelectsFromUsage(paths = [], _params) {
   if (!Array.isArray(paths) || paths.length === 0) {
     return { generatedAppends: void 0, generatedFields: void 0 };
@@ -111,14 +158,23 @@ function inferSelectsFromUsage(paths = [], _params) {
     s = s.replace(/^\./, "").replace(/\.$/, "");
     return s;
   };
-  for (let path of paths) {
-    if (!path) continue;
-    while (/^\[(\d+)\](\.|$)/.test(path)) {
-      path = path.replace(/^\[(\d+)\]\.?/, "");
+  for (const value of paths) {
+    let segments;
+    if (Array.isArray(value)) {
+      if (value.some((segment) => typeof segment === "string" && segment.includes("."))) {
+        return { generatedAppends: void 0, generatedFields: void 0 };
+      }
+      segments = value.filter((segment) => typeof segment === "string" && !!segment);
+    } else {
+      let path = value;
+      if (!path) continue;
+      while (/^\[(\d+)\](\.|$)/.test(path)) {
+        path = path.replace(/^\[(\d+)\]\.?/, "");
+      }
+      const norm = normalizePath(path);
+      if (!norm) continue;
+      segments = norm.split(".").filter(Boolean);
     }
-    const norm = normalizePath(path);
-    if (!norm) continue;
-    const segments = norm.split(".").filter(Boolean);
     if (segments.length === 0) continue;
     if (segments.length === 1) {
       fieldSet.add(segments[0]);
@@ -133,345 +189,111 @@ function inferSelectsFromUsage(paths = [], _params) {
   const generatedFields = fieldSet.size ? Array.from(fieldSet) : void 0;
   return { generatedAppends, generatedFields };
 }
-async function fetchRecordWithRequestCache(koaCtx, dataSourceKey, collection, filterByTk, fields, appends, strictSelects, preferFullRecord, associationName, sourceId) {
-  var _a, _b, _c, _d, _e;
-  try {
-    const log = (_b = (_a = koaCtx.app) == null ? void 0 : _a.logger) == null ? void 0 : _b.child({
-      module: "plugin-flow-engine",
-      submodule: "variables.resolve",
-      method: "fetchRecordWithRequestCache"
-    });
-    const kctx = koaCtx;
-    if (!kctx.state) kctx.state = {};
-    if (!kctx.state["__varResolveBatchCache"]) {
-      kctx.state["__varResolveBatchCache"] = /* @__PURE__ */ new Map();
+function createRecordProviderNode() {
+  return { children: /* @__PURE__ */ new Map() };
+}
+function addRecordProviderBinding(root, binding) {
+  let node = root;
+  for (const segment of binding.prefix) {
+    let child = node.children.get(segment);
+    if (!child) {
+      child = createRecordProviderNode();
+      node.children.set(segment, child);
     }
-    const cache = kctx.state.__varResolveBatchCache || null;
-    const ds = koaCtx.app.dataSourceManager.get(dataSourceKey || "main");
-    const cm = ds.collectionManager;
-    if (!(cm == null ? void 0 : cm.db)) return void 0;
-    const repo = associationName && typeof sourceId !== "undefined" ? cm.db.getRepository(associationName, sourceId) : cm.db.getRepository(collection);
-    const modelInfo = (_c = repo.collection) == null ? void 0 : _c.model;
-    const pkAttr = modelInfo == null ? void 0 : modelInfo.primaryKeyAttribute;
-    const pkIsValid = pkAttr && (modelInfo == null ? void 0 : modelInfo.rawAttributes) && Object.prototype.hasOwnProperty.call(modelInfo.rawAttributes, pkAttr);
-    const collectionInfo = repo == null ? void 0 : repo.collection;
-    const filterTargetKey = collectionInfo == null ? void 0 : collectionInfo.filterTargetKey;
-    const extraKeys = (0, import_records.getExtraKeyFieldsForSelect)(filterByTk, {
-      filterTargetKey,
-      pkAttr,
-      pkIsValid,
-      rawAttributes: (modelInfo == null ? void 0 : modelInfo.rawAttributes) || void 0
-    });
-    const effectiveExtras = strictSelects && Array.isArray(extraKeys) && extraKeys.length ? extraKeys.filter((k) => k === pkAttr) : extraKeys;
-    const fieldsWithExtras = (0, import_records.mergeFieldsWithExtras)(fields, effectiveExtras);
-    const cacheKeyFields = preferFullRecord && pkIsValid ? void 0 : Array.isArray(fieldsWithExtras) ? [...fieldsWithExtras].sort() : void 0;
-    const cacheKeyAppends = preferFullRecord ? void 0 : Array.isArray(appends) ? [...appends].sort() : void 0;
-    const keyObj = {
-      ds: dataSourceKey || "main",
-      c: collection,
-      tk: filterByTk,
-      f: cacheKeyFields,
-      a: cacheKeyAppends,
-      full: preferFullRecord ? true : void 0,
-      assoc: associationName,
-      sid: typeof sourceId === "undefined" ? void 0 : sourceId
-    };
-    const key = JSON.stringify(keyObj);
-    if (cache) {
-      if (cache.has(key)) {
-        return cache.get(key);
-      }
-      if (!strictSelects) {
-        const needFields = !preferFullRecord && Array.isArray(fieldsWithExtras) ? [...new Set(fieldsWithExtras)] : void 0;
-        const needAppends = !preferFullRecord && Array.isArray(appends) ? new Set(appends) : void 0;
-        for (const [cacheKey, cacheVal] of cache.entries()) {
-          const parsed = JSON.parse(cacheKey);
-          if (!parsed || parsed.ds !== keyObj.ds || parsed.c !== keyObj.c || !import_lodash.default.isEqual(parsed.tk, keyObj.tk) || parsed.assoc !== keyObj.assoc || !import_lodash.default.isEqual(parsed.sid, keyObj.sid))
-            continue;
-          const cachedFields = new Set(parsed.f || []);
-          const cachedAppends = new Set(parsed.a || []);
-          const fieldCoveredByAppends = (fieldPath) => {
-            const p = String(fieldPath || "");
-            for (const a of cachedAppends) {
-              if (!a) continue;
-              if (p === a || p.startsWith(a + ".")) return true;
-            }
-            return false;
-          };
-          const fieldsOk = needFields ? needFields.every((f) => cachedFields.has(f) || fieldCoveredByAppends(f)) : parsed.f === void 0;
-          const appendsOk = !needAppends || [...needAppends].every((a) => cachedAppends.has(a));
-          const fullOk = preferFullRecord ? parsed.full === true : true;
-          if (fieldsOk && appendsOk && fullOk) {
-            return cacheVal;
-          }
-        }
-      }
+    node = child;
+  }
+  if (node.binding) return false;
+  node.binding = binding;
+  return true;
+}
+function isProvidedByDescendant(node, path) {
+  let current = node;
+  for (const segment of path) {
+    const child = current.children.get(segment);
+    if (!child) return false;
+    if (child.binding) return true;
+    current = child;
+  }
+  return false;
+}
+function materializeRecordProvider(node, values, inherited) {
+  const base = node.binding ? values.get(node) : inherited;
+  if (!node.children.size) return base;
+  if (Array.isArray(base)) {
+    const result2 = Array.from(node.children.keys()).every(
+      (segment) => typeof segment === "number"
+    ) ? [...base] : Object.assign(/* @__PURE__ */ Object.create(null), base);
+    for (const [segment, child] of node.children) {
+      if (typeof segment !== "number") continue;
+      result2[segment] = materializeRecordProvider(child, values, result2[segment]);
     }
-    const json = await (0, import_records.fetchRecordOrRecordsJson)(repo, {
-      filterByTk,
-      preferFullRecord,
-      fields: fieldsWithExtras,
-      appends,
-      filterTargetKey,
-      pkAttr,
-      pkIsValid
-    });
-    if (cache) cache.set(key, json);
-    return json;
-  } catch (e) {
-    const log = (_e = (_d = koaCtx.app) == null ? void 0 : _d.logger) == null ? void 0 : _e.child({
-      module: "plugin-flow-engine",
-      submodule: "variables.resolve",
-      method: "fetchRecordWithRequestCache"
-    });
-    const errMsg = e instanceof Error ? e.message : String(e);
-    log == null ? void 0 : log.warn("[variables.resolve] fetchRecordWithRequestCache error", {
-      ds: dataSourceKey,
-      collection,
-      tk: filterByTk,
-      fields,
-      appends,
-      error: errMsg
-    });
-    return void 0;
+    return result2;
   }
+  const result = import_lodash.default.isPlainObject(base) ? { ...base } : /* @__PURE__ */ Object.create(null);
+  for (const [segment, child] of node.children) {
+    const key = String(segment);
+    result[key] = materializeRecordProvider(child, values, result[key]);
+  }
+  return result;
 }
-function isRecordParams(val) {
-  return val && typeof val === "object" && "collection" in val && "filterByTk" in val;
+function isSafeRecordBinding(binding) {
+  return !(0, import_context_keys.isProtectedServerContextKey)(binding.varName);
 }
-function attachGenericRecordVariables(flowCtx, koaCtx, usage, contextParams) {
-  const parseIndexSegment = (segment) => {
-    const m = segment.match(/^\[(\d+)\]$/);
-    return m ? m[1] : void 0;
-  };
-  for (const varName of Object.keys(usage)) {
-    const usedPaths = usage[varName] || [];
-    const topParams = import_lodash.default.get(contextParams, varName);
-    const deepRecordMap = /* @__PURE__ */ new Map();
-    const cp = contextParams;
-    if (cp && typeof cp === "object") {
-      const cpRec = cp;
-      for (const key of Object.keys(cpRec)) {
-        if (!key || key !== varName && !key.startsWith(`${varName}.`)) continue;
-        if (key === varName) continue;
-        const val = cpRec[key];
-        if (!isRecordParams(val)) continue;
-        const relative = key.slice(varName.length + 1);
-        if (!relative) continue;
-        deepRecordMap.set(relative, val);
-      }
+async function fetchBindingRecord(koaCtx, binding, relativePaths = binding.relativePaths) {
+  const strictSelects = Array.isArray(binding.params.fields) || Array.isArray(binding.params.appends);
+  let { generatedAppends, generatedFields } = inferSelectsFromUsage(relativePaths);
+  if (Array.isArray(binding.params.fields)) generatedFields = binding.params.fields;
+  if (Array.isArray(binding.params.appends)) generatedAppends = binding.params.appends;
+  const raw = await (0, import_records.fetchRecordWithRequestCache)(
+    koaCtx,
+    binding.params,
+    generatedFields,
+    generatedAppends,
+    strictSelects,
+    binding.preferFullRecord || relativePaths.some((path) => path.some((segment) => typeof segment === "string" && segment.includes(".")))
+  );
+  return (0, import_record_projection.projectRecord)(raw, relativePaths);
+}
+function attachAuthorizedRecordBindings(flowCtx, koaCtx, bindings) {
+  const byVariable = /* @__PURE__ */ new Map();
+  const conflicts = /* @__PURE__ */ new Set();
+  for (const binding of bindings) {
+    if (!isSafeRecordBinding(binding)) continue;
+    let root = byVariable.get(binding.varName);
+    if (!root) {
+      root = createRecordProviderNode();
+      byVariable.set(binding.varName, root);
     }
-    if (isRecordParams(topParams)) {
-      const usedPathsForBase = deepRecordMap.size ? (usedPaths || []).filter((p) => {
-        if (!p) return true;
-        for (const relative of deepRecordMap.keys()) {
-          if (!relative) continue;
-          if (p === relative || p.startsWith(relative + ".") || p.startsWith(relative + "[")) return false;
+    if (!addRecordProviderBinding(root, binding)) conflicts.add(binding.varName);
+  }
+  for (const [varName, root] of byVariable) {
+    if (conflicts.has(varName)) continue;
+    const resolveNode = async (node) => {
+      const entries = [];
+      const collect = (current) => {
+        if (current.binding) {
+          const paths = current.binding.relativePaths.filter((path) => !isProvidedByDescendant(current, path));
+          entries.push([current, fetchBindingRecord(koaCtx, current.binding, paths)]);
         }
-        return true;
-      }) : usedPaths || [];
-      const hasDirectRefTop = usedPathsForBase.some((p) => p === "");
-      flowCtx.defineProperty(varName, {
-        get: async () => {
-          const dataSourceKey = (topParams == null ? void 0 : topParams.dataSourceKey) || "main";
-          const strictSelects = Array.isArray(topParams == null ? void 0 : topParams.fields) || Array.isArray(topParams == null ? void 0 : topParams.appends);
-          let { generatedAppends, generatedFields } = inferSelectsFromUsage(usedPathsForBase, topParams);
-          if (Array.isArray(topParams == null ? void 0 : topParams.fields)) generatedFields = topParams.fields;
-          if (Array.isArray(topParams == null ? void 0 : topParams.appends)) generatedAppends = topParams.appends;
-          const fixed = (0, import_selects.adjustSelectsForCollection)(
-            koaCtx,
-            dataSourceKey,
-            topParams.collection,
-            generatedFields,
-            generatedAppends
-          );
-          const base = await fetchRecordWithRequestCache(
-            koaCtx,
-            dataSourceKey,
-            topParams.collection,
-            topParams.filterByTk,
-            fixed.fields,
-            fixed.appends,
-            strictSelects,
-            hasDirectRefTop,
-            topParams.associationName,
-            topParams.sourceId
-          );
-          if (!deepRecordMap.size) return base;
-          const merged = base && typeof base === "object" && !Array.isArray(base) ? { ...base } : {};
-          const setClonedPath = (obj, path, value) => {
-            const segs = String(path || "").split(".").filter(Boolean);
-            if (!segs.length) return;
-            if (segs.length === 1) {
-              obj[segs[0]] = value;
-              return;
-            }
-            let cur = obj;
-            for (let i = 0; i < segs.length - 1; i++) {
-              const seg = segs[i];
-              const prev = cur[seg];
-              const next = prev && typeof prev === "object" && !Array.isArray(prev) ? { ...prev } : {};
-              cur[seg] = next;
-              cur = next;
-            }
-            cur[segs[segs.length - 1]] = value;
-          };
-          const buildNestedPromise = (recordParams, relative) => {
-            const subPaths = (usedPaths || []).map((p) => p === relative ? "" : p.startsWith(relative + ".") ? p.slice(relative.length + 1) : "").filter((x) => x !== "");
-            const hasDirectRef = (usedPaths || []).some((p) => p === relative);
-            const dataSourceKey2 = (recordParams == null ? void 0 : recordParams.dataSourceKey) || "main";
-            const strictSelects2 = Array.isArray(recordParams == null ? void 0 : recordParams.fields) || Array.isArray(recordParams == null ? void 0 : recordParams.appends);
-            let { generatedAppends: generatedAppends2, generatedFields: generatedFields2 } = inferSelectsFromUsage(subPaths, recordParams);
-            if (Array.isArray(recordParams == null ? void 0 : recordParams.fields)) generatedFields2 = recordParams.fields;
-            if (Array.isArray(recordParams == null ? void 0 : recordParams.appends)) generatedAppends2 = recordParams.appends;
-            const fixed2 = (0, import_selects.adjustSelectsForCollection)(
-              koaCtx,
-              dataSourceKey2,
-              recordParams.collection,
-              generatedFields2,
-              generatedAppends2
-            );
-            return fetchRecordWithRequestCache(
-              koaCtx,
-              dataSourceKey2,
-              recordParams.collection,
-              recordParams.filterByTk,
-              fixed2.fields,
-              fixed2.appends,
-              strictSelects2,
-              hasDirectRef,
-              recordParams.associationName,
-              recordParams.sourceId
-            );
-          };
-          for (const [relative, recordParams] of deepRecordMap.entries()) {
-            setClonedPath(merged, relative, buildNestedPromise(recordParams, relative));
-          }
-          return merged;
-        },
-        cache: true
-      });
-      continue;
-    }
-    const segmentMap = /* @__PURE__ */ new Map();
-    const splitHead = (path) => {
-      if (!path) return { seg: "", remainder: "" };
-      const mIdx = path.match(/^\[(\d+)\](?:\.(.*))?$/);
-      if (mIdx) {
-        return { seg: `[${mIdx[1]}]`, remainder: mIdx[2] || "" };
-      }
-      const m = path.match(/^([a-zA-Z_$][a-zA-Z0-9_$]*)(\[(?:\d+|"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')\])?(?:\.(.*))?$/);
-      if (m) {
-        const seg2 = m[1];
-        const idxPart = m[2] || "";
-        const tail = m[3] || "";
-        const remainder = (idxPart ? `${idxPart}${tail ? `.${tail}` : ""}` : tail) || "";
-        return { seg: seg2, remainder };
+        for (const child of current.children.values()) collect(child);
+      };
+      collect(node);
+      const values = /* @__PURE__ */ new Map();
+      await Promise.all(entries.map(async ([current, pending]) => values.set(current, await pending)));
+      return materializeRecordProvider(node, values);
+    };
+    const createProxy = (node) => {
+      const context = new import_contexts.ServerBaseContext();
+      for (const [segment, child] of node.children) {
+        context.defineProperty(String(segment), {
+          get: () => child.binding ? resolveNode(child) : createProxy(child),
+          cache: true
+        });
       }
-      const [seg, ...rest] = path.split(".");
-      return { seg, remainder: rest.join(".") };
+      return context.createProxy();
     };
-    for (const p of usedPaths) {
-      if (!p) continue;
-      const { seg, remainder } = splitHead(p);
-      if (!seg) continue;
-      const arr = segmentMap.get(seg) || [];
-      arr.push(remainder);
-      segmentMap.set(seg, arr);
-    }
-    const segEntries = Array.from(segmentMap.entries());
-    const oneLevelRecordChildren = segEntries.filter(([seg]) => {
-      const idx = parseIndexSegment(seg);
-      const nestedObj = import_lodash.default.get(contextParams, [varName, seg]) ?? (idx ? import_lodash.default.get(contextParams, [varName, idx]) : void 0);
-      const dotted = (contextParams || {})[`${varName}.${seg}`] ?? (idx ? (contextParams || {})[`${varName}.${idx}`] : void 0);
-      return isRecordParams(nestedObj) || isRecordParams(dotted);
-    });
-    if (!oneLevelRecordChildren.length && deepRecordMap.size === 0) continue;
     flowCtx.defineProperty(varName, {
-      get: () => {
-        const root = new import_contexts.ServerBaseContext();
-        const definedFirstLevel = /* @__PURE__ */ new Set();
-        const defineRecordGetter = (container, key, recordParams, subPaths = [], preferFull) => {
-          const strictSelects = Array.isArray(recordParams == null ? void 0 : recordParams.fields) || Array.isArray(recordParams == null ? void 0 : recordParams.appends);
-          let { generatedAppends, generatedFields } = inferSelectsFromUsage(subPaths, recordParams);
-          if (Array.isArray(recordParams == null ? void 0 : recordParams.fields)) generatedFields = recordParams.fields;
-          if (Array.isArray(recordParams == null ? void 0 : recordParams.appends)) generatedAppends = recordParams.appends;
-          container.defineProperty(key, {
-            get: async () => {
-              const dataSourceKey = (recordParams == null ? void 0 : recordParams.dataSourceKey) || "main";
-              const fixed = (0, import_selects.adjustSelectsForCollection)(
-                koaCtx,
-                dataSourceKey,
-                recordParams.collection,
-                generatedFields,
-                generatedAppends
-              );
-              return await fetchRecordWithRequestCache(
-                koaCtx,
-                dataSourceKey,
-                recordParams.collection,
-                recordParams.filterByTk,
-                fixed.fields,
-                fixed.appends,
-                strictSelects,
-                preferFull || ((subPaths == null ? void 0 : subPaths.length) ?? 0) === 0,
-                recordParams.associationName,
-                recordParams.sourceId
-              );
-            },
-            cache: true
-          });
-        };
-        const subContainers = /* @__PURE__ */ new Map();
-        const ensureSubContainer = (parent, key) => {
-          let map = subContainers.get(parent);
-          if (!map) {
-            map = /* @__PURE__ */ new Map();
-            subContainers.set(parent, map);
-          }
-          let child = map.get(key);
-          if (!child) {
-            const inst = new import_contexts.ServerBaseContext();
-            parent.defineProperty(key, { get: () => inst.createProxy(), cache: true });
-            map.set(key, inst);
-            child = inst;
-          }
-          return child;
-        };
-        for (const [seg, remainders] of oneLevelRecordChildren) {
-          const idx = parseIndexSegment(seg);
-          const recordParams = import_lodash.default.get(contextParams, [varName, seg]) ?? (idx ? import_lodash.default.get(contextParams, [varName, idx]) : void 0) ?? (contextParams || {})[`${varName}.${seg}`] ?? (idx ? (contextParams || {})[`${varName}.${idx}`] : void 0);
-          let effRemainders = (remainders || []).filter((r) => !!r);
-          if (!effRemainders.length) {
-            const all = usedPaths.map(
-              (p) => p.startsWith(`${seg}.`) ? p.slice(seg.length + 1) : p.startsWith(`${seg}[`) ? p.slice(seg.length) : ""
-            ).filter((x) => !!x);
-            if (all.length) effRemainders = all;
-          }
-          const hasDirectRefOne = (usedPaths || []).some((p) => p === seg || !!idx && p === `[${idx}]`);
-          defineRecordGetter(root, idx ?? seg, recordParams, effRemainders, hasDirectRefOne);
-          definedFirstLevel.add(idx ?? seg);
-        }
-        for (const [relative, recordParams] of deepRecordMap.entries()) {
-          const segs = String(relative).split(".").filter(Boolean);
-          if (segs.length === 0) continue;
-          const first = segs[0];
-          let container;
-          if (definedFirstLevel.has(first)) {
-            continue;
-          } else {
-            container = root;
-            for (let i = 0; i < segs.length - 1; i++) {
-              container = ensureSubContainer(container, segs[i]);
-            }
-          }
-          const leaf = segs[segs.length - 1];
-          const subPaths = (usedPaths || []).map((p) => p === relative ? "" : p.startsWith(relative + ".") ? p.slice(relative.length + 1) : "").filter((x) => x !== "");
-          const hasDirectRef = (usedPaths || []).some((p) => p === relative);
-          defineRecordGetter(container, leaf, recordParams, subPaths, hasDirectRef);
-        }
-        return root.createProxy();
-      },
+      get: () => root.binding ? resolveNode(root) : createProxy(root),
       cache: true
     });
   }
@@ -481,30 +303,39 @@ function registerBuiltInVariables(reg) {
     name: "user",
     scope: "request",
     // no requiredParams: frontend will not pass context params for user
+    validateContextParams: ({ contextParams }) => ({
+      allowed: true,
+      contextParams: omitVariableContextParams(contextParams, "user")
+    }),
     attach: (flowCtx, koaCtx, _params, usage) => {
-      const paths = (usage == null ? void 0 : usage["user"]) || [];
+      const paths = ((usage == null ? void 0 : usage.user) || []).map((path) => path.runtimeSegments);
       const { generatedAppends, generatedFields } = inferSelectsFromUsage(paths);
-      flowCtx.defineProperty("user", {
-        get: async () => {
-          var _a;
-          const authObj = koaCtx.auth;
-          const uid = (_a = authObj == null ? void 0 : authObj.user) == null ? void 0 : _a.id;
-          if (typeof uid === "undefined" || uid === null) return void 0;
-          return await fetchRecordWithRequestCache(
-            koaCtx,
-            "main",
-            "users",
-            uid,
-            generatedFields,
-            generatedAppends,
-            false,
-            void 0,
-            void 0,
-            void 0
-          );
+      flowCtx.defineProperty(
+        "user",
+        {
+          get: async () => {
+            var _a;
+            const authObj = koaCtx.auth;
+            const uid = (_a = authObj == null ? void 0 : authObj.user) == null ? void 0 : _a.id;
+            if (typeof uid === "undefined" || uid === null) return void 0;
+            return await (0, import_records.fetchRecordWithRequestCache)(
+              koaCtx,
+              { collection: "users", dataSourceKey: "main", filterByTk: uid },
+              generatedFields,
+              generatedAppends,
+              false
+            );
+          },
+          cache: true
         },
-        cache: true
-      });
+        import_contexts.SERVER_CONTEXT_PROVIDER_TOKEN
+      );
+    }
+  });
+  reg.register({
+    name: "popup",
+    scope: "request",
+    attach: () => {
     }
   });
 }
@@ -512,5 +343,9 @@ registerBuiltInVariables(variables);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   inferSelectsFromUsage,
+  isSafeRecordBinding,
+  omitVariableContextParams,
+  registerBuiltInVariables,
+  sanitizeRegisteredVariableContextParams,
   variables
 });