@nocobase/plugin-flow-engine 3.0.0-alpha.1 → 3.0.0-alpha.12

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

@@ -0,0 +1,280 @@
+/**
+ * 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 form_item_record_slot_resolvers_exports = {};
+__export(form_item_record_slot_resolvers_exports, {
+  createFormItemRecordSlotResolvers: () => createFormItemRecordSlotResolvers
+});
+module.exports = __toCommonJS(form_item_record_slot_resolvers_exports);
+function isObject(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function getModelOptions(value) {
+  if (!isObject(value)) return void 0;
+  return isObject(value.options) ? value.options : value;
+}
+function getNodeString(value, key) {
+  if (!isObject(value)) return void 0;
+  const nodeValue = value[key];
+  return typeof nodeValue === "string" && nodeValue ? nodeValue : void 0;
+}
+function getStepInit(options, flowKey) {
+  if (!isObject(options.stepParams)) return void 0;
+  const step = options.stepParams[flowKey];
+  return isObject(step) && isObject(step.init) ? step.init : void 0;
+}
+function readString(target, key) {
+  if (!isObject(target)) return void 0;
+  const direct = target[key];
+  if (typeof direct === "string" && direct.trim()) return direct.trim();
+  const options = target.options;
+  const nested = isObject(options) ? options[key] : void 0;
+  return typeof nested === "string" && nested.trim() ? nested.trim() : void 0;
+}
+function callMethod(target, name, ...args) {
+  if (!isObject(target) || typeof target[name] !== "function") return void 0;
+  return target[name].apply(target, args);
+}
+function getResourceTarget(options) {
+  const init = getStepInit(options, "resourceSettings");
+  const collection = typeof (init == null ? void 0 : init.collectionName) === "string" ? init.collectionName.trim() : "";
+  const dataSourceKey = typeof (init == null ? void 0 : init.dataSourceKey) === "string" ? init.dataSourceKey.trim() : "main";
+  const associationName = typeof (init == null ? void 0 : init.associationName) === "string" ? init.associationName.trim() : void 0;
+  if (!collection || !dataSourceKey || typeof (init == null ? void 0 : init.associationName) === "string" && !associationName) {
+    return void 0;
+  }
+  return { collection, dataSourceKey, ...associationName ? { associationName } : {} };
+}
+function getFieldTarget(input, source, fieldName) {
+  var _a;
+  const field = callMethod(source.collection, "getField", fieldName);
+  const association = callMethod(field, "isAssociationField") === true || callMethod(field, "isRelationField") === true;
+  if (!association) return void 0;
+  const rawTargetCollection = isObject(field) ? field.targetCollection : void 0;
+  const targetCollection = typeof rawTargetCollection === "function" ? rawTargetCollection.call(field) : rawTargetCollection;
+  const collectionName = readString(targetCollection, "name") || readString(field, "target");
+  const dataSourceKey = readString(targetCollection, "dataSourceKey") || source.dataSourceKey;
+  const collection = targetCollection || collectionName && ((_a = input.getCollection) == null ? void 0 : _a.call(input, dataSourceKey, collectionName));
+  if (!collectionName || !collection) return void 0;
+  return { source, target: { collection, collectionName, dataSourceKey } };
+}
+function resolveAssociationPath(input, source, path) {
+  let current = source;
+  let edge;
+  for (const segment of path) {
+    edge = getFieldTarget(input, current, segment);
+    if (!edge) return void 0;
+    current = edge.target;
+  }
+  return edge;
+}
+function resolveResourceCollection(input, resource) {
+  var _a, _b, _c;
+  let sourceName = resource.collection;
+  const associationPath = ((_a = resource.associationName) == null ? void 0 : _a.split(".").filter(Boolean)) || [];
+  if (associationPath.length > 1) sourceName = associationPath.shift() || sourceName;
+  const collection = (_b = input.getCollection) == null ? void 0 : _b.call(input, resource.dataSourceKey, sourceName);
+  if (!collection) return void 0;
+  const source = { collection, collectionName: sourceName, dataSourceKey: resource.dataSourceKey };
+  return associationPath.length ? (_c = resolveAssociationPath(input, source, associationPath)) == null ? void 0 : _c.target : source;
+}
+function getSubModel(options, name) {
+  return isObject(options.subModels) ? options.subModels[name] : void 0;
+}
+function getFormItems(form) {
+  const grid = getModelOptions(getSubModel(form, "grid"));
+  if (!grid) return void 0;
+  const items = getSubModel(grid, "items");
+  return Array.isArray(items) ? items.map(getModelOptions).filter((item) => !!item) : void 0;
+}
+function getFieldPath(options) {
+  const init = getStepInit(options, "fieldSettings");
+  const fieldPath = typeof (init == null ? void 0 : init.fieldPath) === "string" ? init.fieldPath.trim() : "";
+  const associationPath = typeof (init == null ? void 0 : init.associationPathName) === "string" ? init.associationPathName.trim() : "";
+  if (!fieldPath) return void 0;
+  if (!associationPath || fieldPath === associationPath || fieldPath.startsWith(`${associationPath}.`))
+    return fieldPath;
+  return `${associationPath}.${fieldPath}`;
+}
+function getFieldSource(input, options) {
+  var _a;
+  const init = getStepInit(options, "fieldSettings");
+  const collectionName = typeof (init == null ? void 0 : init.collectionName) === "string" ? init.collectionName.trim() : "";
+  const dataSourceKey = typeof (init == null ? void 0 : init.dataSourceKey) === "string" ? init.dataSourceKey.trim() : "main";
+  const collection = collectionName && dataSourceKey ? (_a = input.getCollection) == null ? void 0 : _a.call(input, dataSourceKey, collectionName) : void 0;
+  return collection ? { collection, collectionName, dataSourceKey } : void 0;
+}
+function isJsonField(field) {
+  return ["json", "jsonb"].includes(
+    String(readString(field, "type") || readString(field, "interface") || "").toLowerCase()
+  );
+}
+function pathStartsWith(path, prefix) {
+  return prefix.length <= path.length && prefix.every((segment, index) => path[index] === segment);
+}
+function resolved(slot) {
+  return { status: "resolved", slot };
+}
+async function getLineage(input) {
+  const ancestors = input.loadAncestors ? await input.loadAncestors() : [];
+  const lineage = [input.currentNode, ...ancestors].filter((node) => !!node);
+  for (let index = 0; index + 1 < lineage.length; index++) {
+    const parentId = getNodeString(lineage[index], "parentId");
+    const parentUid = getNodeString(lineage[index + 1], "uid");
+    if (parentId && parentUid && parentId !== parentUid) throw new Error("Invalid FlowModel lineage");
+  }
+  return lineage;
+}
+async function loadModelTree(input, node) {
+  const options = getModelOptions(node);
+  if (options && getFormItems(options)) return options;
+  const uid = isObject(node) && typeof node.uid === "string" ? node.uid : void 0;
+  if (!uid || !input.ctx) return void 0;
+  const repository = input.ctx.db.getCollection("flowModels").repository;
+  return getModelOptions(await repository.findModelById(uid, { includeAsyncNode: true }));
+}
+async function findFormProvider(input, lineage) {
+  for (const node of lineage) {
+    const options = getModelOptions(node);
+    if (!options || !getFormItems(options) && !getResourceTarget(options)) continue;
+    const form = await loadModelTree(input, node);
+    const items = form && getFormItems(form);
+    if (!form || !items) continue;
+    const resource = getResourceTarget(form);
+    return resource ? { collection: resolveResourceCollection(input, resource), items } : void 0;
+  }
+  return void 0;
+}
+function getConfiguredAssociationSlots(input, source, items) {
+  var _a;
+  const slots = /* @__PURE__ */ new Map();
+  const fieldPaths = [];
+  for (const item of items) {
+    const fieldPath = ((_a = getFieldPath(item)) == null ? void 0 : _a.split(".").filter(Boolean)) || [];
+    if (fieldPath.length) fieldPaths.push(fieldPath);
+    let current = source;
+    const prefix = [];
+    for (const segment of fieldPath) {
+      const edge = getFieldTarget(input, current, segment);
+      if (!edge) break;
+      prefix.push(segment);
+      slots.set(prefix.join("."), [...prefix]);
+      current = edge.target;
+    }
+  }
+  return { fieldPaths, slots: [...slots.values()] };
+}
+async function resolveFormValues(input) {
+  const lineage = await getLineage(input);
+  const provider = await findFormProvider(input, lineage);
+  if (!provider) return { status: "abstain" };
+  if (!provider.collection) return { status: "deny" };
+  const runtimePath = input.path.runtimeSegments;
+  const configuredSlots = getConfiguredAssociationSlots(input, provider.collection, provider.items);
+  let configured;
+  for (const slot of configuredSlots.slots) {
+    if (pathStartsWith(runtimePath, slot) && (!configured || slot.length > configured.length)) configured = slot;
+  }
+  if (configured) return resolved(configured);
+  const top = runtimePath[0];
+  if (typeof top !== "string") return runtimePath.length ? { status: "deny" } : resolved([]);
+  const field = callMethod(provider.collection.collection, "getField", top);
+  const configuredField = configuredSlots.fieldPaths.some(
+    (fieldPath) => pathStartsWith(runtimePath, fieldPath) || runtimePath.length <= fieldPath.length && runtimePath.every((segment, index) => fieldPath[index] === segment)
+  );
+  return field && !isJsonField(field) && !configuredField ? resolved([]) : { status: "deny" };
+}
+function sameCollection(left, right) {
+  return left.dataSourceKey === right.dataSourceKey && left.collectionName === right.collectionName;
+}
+function getAssociationEdge(input, options) {
+  var _a;
+  const source = getFieldSource(input, options);
+  const fullPath = (_a = getFieldPath(options)) == null ? void 0 : _a.split(".").filter(Boolean);
+  if (!source || !(fullPath == null ? void 0 : fullPath.length)) return void 0;
+  return resolveAssociationPath(input, source, fullPath);
+}
+function hasItemProviderBranch(lineage, providerIndex) {
+  return providerIndex === 0 || lineage.slice(0, providerIndex).some((node) => ["grid", "popup"].includes(getNodeString(node, "subKey") || ""));
+}
+function getItemCollectionChain(input, lineage) {
+  const edges = [];
+  for (const [index, node] of lineage.entries()) {
+    const options = getModelOptions(node);
+    const edge = options && getAssociationEdge(input, options);
+    if (!edge || !hasItemProviderBranch(lineage, index)) continue;
+    const previous = edges[edges.length - 1];
+    if (previous && sameCollection(previous.source, edge.source) && sameCollection(previous.target, edge.target))
+      continue;
+    edges.push(edge);
+  }
+  if (!edges.length) return [];
+  const collections = [edges[0].target, edges[0].source];
+  let edgeIndex = 1;
+  while (edgeIndex < edges.length) {
+    const parent = collections[collections.length - 1];
+    const matches = edges.slice(edgeIndex).filter((edge) => sameCollection(edge.target, parent));
+    if (!matches.length) break;
+    if (matches.some((edge) => !sameCollection(edge.source, matches[0].source))) return [];
+    collections.push(matches[0].source);
+    edgeIndex = edges.indexOf(matches[0], edgeIndex) + 1;
+  }
+  return collections;
+}
+async function resolveItem(input) {
+  const runtimePath = input.path.runtimeSegments;
+  let parentDepth = 0;
+  while (runtimePath[parentDepth] === "parentItem") parentDepth += 1;
+  if (runtimePath[parentDepth] !== "value") return { status: "abstain" };
+  const associationName = runtimePath[parentDepth + 1];
+  if (typeof associationName !== "string") return { status: "abstain" };
+  const collections = getItemCollectionChain(input, await getLineage(input));
+  const collection = collections[parentDepth];
+  if (!collection || !getFieldTarget(input, collection, associationName)) return { status: "deny" };
+  return resolved([...runtimePath.slice(0, parentDepth + 1), associationName]);
+}
+function createFormItemRecordSlotResolvers() {
+  return [
+    {
+      owner: "@nocobase/plugin-flow-engine",
+      id: "form:values",
+      match: (path) => path.varName === "formValues",
+      needsAncestors: true,
+      resolve: resolveFormValues
+    },
+    {
+      owner: "@nocobase/plugin-flow-engine",
+      id: "form:item",
+      match: (path) => path.varName === "item",
+      needsAncestors: true,
+      resolve: resolveItem
+    }
+  ];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createFormItemRecordSlotResolvers
+});

package/dist/server/variables/record-bindings.d.ts

@@ -0,0 +1,42 @@
+/**
+ * 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 { PathSegment, VariablePathRef } from '../template/variable-expression';
+import { type RecordParams } from './records';
+import type { RecordSlotPolicies } from './record-slot-policy';
+export type AuthorizedRecordBinding = Readonly<{
+    params: RecordParams;
+    varName: string;
+    prefix: readonly PathSegment[];
+    relativePaths: readonly (readonly PathSegment[])[];
+    preferFullRecord: boolean;
+    contextKey: string;
+    contextLocation: readonly PathSegment[];
+}>;
+export type RecordBindingRejectionReason = 'protected-context-root' | 'protected-context-key';
+export type RecordBindingRejection = Readonly<{
+    reason: RecordBindingRejectionReason;
+    varName: string;
+    prefix: readonly PathSegment[];
+    contextKey: string;
+    contextLocation: readonly PathSegment[];
+}>;
+export type RecordBindingPlan = Readonly<{
+    bindings: readonly AuthorizedRecordBinding[];
+    contextParams: Readonly<Record<string, unknown>>;
+    rejections: readonly RecordBindingRejection[];
+}>;
+export type RecordBindingUsage = Readonly<Record<string, readonly VariablePathRef[]>>;
+export type PlanRecordBindingsOptions = Readonly<{
+    contextParams?: Readonly<Record<string, unknown>>;
+    koaCtx: ResourcerContext;
+    policies?: RecordSlotPolicies;
+    usage: RecordBindingUsage;
+}>;
+export declare function planRecordBindings(options: PlanRecordBindingsOptions): Promise<RecordBindingPlan>;

package/dist/server/variables/record-bindings.js

@@ -0,0 +1,196 @@
+/**
+ * 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_bindings_exports = {};
+__export(record_bindings_exports, {
+  planRecordBindings: () => planRecordBindings
+});
+module.exports = __toCommonJS(record_bindings_exports);
+var import_context_keys = require("../template/context-keys");
+var import_records = require("./records");
+const removedRecordParams = Symbol("removed-record-params");
+const blockedBindingSegments = /* @__PURE__ */ new Set([...import_context_keys.SERVER_CONTEXT_PROTOTYPE_KEYS, ...import_context_keys.SERVER_CONTEXT_INTERNAL_KEYS]);
+function normalizeFlatSegment(segment) {
+  return /^\d+$/.test(segment) ? Number(segment) : segment;
+}
+function splitFlatContextKey(key) {
+  const [varName, ...prefix] = key.split(".");
+  return [varName, ...prefix.map(normalizeFlatSegment)];
+}
+function cloneRecordParams(params) {
+  return Object.freeze({
+    ...params,
+    ...Array.isArray(params.fields) ? { fields: Object.freeze([...params.fields]) } : {},
+    ...Array.isArray(params.appends) ? { appends: Object.freeze([...params.appends]) } : {}
+  });
+}
+function isRecordDescriptor(value) {
+  return !!value && typeof value === "object" && Object.prototype.hasOwnProperty.call(value, "collection") && Object.prototype.hasOwnProperty.call(value, "filterByTk");
+}
+function getRecordParams(value) {
+  if (!(0, import_records.isRecordParams)(value) || !value.collection) return void 0;
+  if (typeof value.dataSourceKey !== "undefined" && typeof value.dataSourceKey !== "string") return void 0;
+  if (typeof value.associationName !== "undefined" && typeof value.associationName !== "string") return void 0;
+  if (typeof value.fields !== "undefined" && (!Array.isArray(value.fields) || !value.fields.every((field) => typeof field === "string"))) {
+    return void 0;
+  }
+  if (typeof value.appends !== "undefined" && (!Array.isArray(value.appends) || !value.appends.every((append) => typeof append === "string"))) {
+    return void 0;
+  }
+  return cloneRecordParams(value);
+}
+function collectDescriptorsAndContextParams(contextParams) {
+  const descriptors = [];
+  const visit = (value, varName, prefix, contextKey, contextLocation) => {
+    if (isRecordDescriptor(value)) {
+      descriptors.push({
+        contextKey,
+        contextLocation: Object.freeze([...contextLocation]),
+        params: getRecordParams(value),
+        prefix: Object.freeze([...prefix]),
+        varName
+      });
+      return removedRecordParams;
+    }
+    if (Array.isArray(value)) {
+      return Object.freeze(
+        value.map((child, index) => {
+          const next = visit(child, varName, [...prefix, index], contextKey, [...contextLocation, index]);
+          return next === removedRecordParams ? void 0 : next;
+        })
+      );
+    }
+    if (!value || typeof value !== "object") return value;
+    const entries = [];
+    for (const [key, child] of Object.entries(value)) {
+      const next = visit(child, varName, [...prefix, key], contextKey, [...contextLocation, key]);
+      if (next !== removedRecordParams) entries.push([key, next]);
+    }
+    return Object.freeze(Object.fromEntries(entries));
+  };
+  const cleaned = [];
+  for (const [contextKey, value] of Object.entries(contextParams)) {
+    const [varName, ...prefix] = splitFlatContextKey(contextKey);
+    const next = visit(value, varName, prefix, contextKey, [contextKey]);
+    if (next !== removedRecordParams) cleaned.push([contextKey, next]);
+  }
+  return { contextParams: Object.freeze(Object.fromEntries(cleaned)), descriptors };
+}
+function getDescriptorKey(varName, prefix) {
+  return JSON.stringify([varName, ...prefix]);
+}
+function groupDescriptors(descriptors) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const descriptor of descriptors) {
+    const key = getDescriptorKey(descriptor.varName, descriptor.prefix);
+    const group = groups.get(key) || [];
+    group.push(descriptor);
+    groups.set(key, group);
+  }
+  return groups;
+}
+function createRejection(descriptor, reason) {
+  return Object.freeze({
+    reason,
+    varName: descriptor.varName,
+    prefix: descriptor.prefix,
+    contextKey: descriptor.contextKey,
+    contextLocation: descriptor.contextLocation
+  });
+}
+function hasBlockedSegment(path) {
+  return path.some((segment) => typeof segment === "string" && blockedBindingSegments.has(segment));
+}
+function hasValidParams(descriptor) {
+  return !!descriptor.params;
+}
+function createBinding(descriptor, paths) {
+  const relativePaths = paths.map((path) => Object.freeze(path.runtimeSegments.slice(descriptor.prefix.length)));
+  return Object.freeze({
+    params: cloneRecordParams(descriptor.params),
+    varName: descriptor.varName,
+    prefix: descriptor.prefix,
+    relativePaths: Object.freeze(relativePaths),
+    preferFullRecord: relativePaths.some((path) => path.length === 0),
+    contextKey: descriptor.contextKey,
+    contextLocation: descriptor.contextLocation
+  });
+}
+async function planStrictBindings(options, descriptorGroups) {
+  var _a;
+  const blockedDescriptors = /* @__PURE__ */ new Set();
+  const rejections = [];
+  for (const descriptors of descriptorGroups.values()) {
+    for (const descriptor of descriptors) {
+      const reason = (0, import_context_keys.isProtectedServerContextKey)(descriptor.varName) ? "protected-context-root" : hasBlockedSegment(descriptor.prefix) ? "protected-context-key" : void 0;
+      if (!reason) continue;
+      blockedDescriptors.add(descriptor);
+      rejections.push(createRejection(descriptor, reason));
+    }
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (const refs of Object.values(options.usage)) {
+    for (const ref of refs) {
+      const policy = (_a = options.policies) == null ? void 0 : _a.get(ref.canonicalKey);
+      if (!policy) continue;
+      const descriptorKey = getDescriptorKey(ref.varName, policy.slot);
+      const existing = groups.get(descriptorKey);
+      const group = existing || {
+        descriptorKey,
+        paths: []
+      };
+      group.paths.push(ref);
+      groups.set(descriptorKey, group);
+    }
+  }
+  const bindings = [];
+  for (const group of groups.values()) {
+    const candidates = descriptorGroups.get(group.descriptorKey) || [];
+    if (candidates.length !== 1 || !hasValidParams(candidates[0])) continue;
+    const descriptor = candidates[0];
+    if (blockedDescriptors.has(descriptor)) continue;
+    if (group.paths.some((path) => hasBlockedSegment(path.runtimeSegments))) {
+      rejections.push(createRejection(descriptor, "protected-context-key"));
+      continue;
+    }
+    bindings.push(createBinding(descriptor, group.paths));
+  }
+  return { bindings, rejections };
+}
+async function planRecordBindings(options) {
+  const { contextParams, descriptors } = collectDescriptorsAndContextParams(options.contextParams ?? {});
+  const descriptorGroups = groupDescriptors(descriptors);
+  const { bindings, rejections } = await planStrictBindings(options, descriptorGroups);
+  return Object.freeze({
+    bindings: Object.freeze(bindings),
+    contextParams,
+    rejections: Object.freeze(rejections)
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  planRecordBindings
+});

package/dist/server/variables/record-projection.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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 { PathSegment } from '../template/variable-expression';
+export declare function projectRecord(raw: unknown, exposedPaths: readonly (readonly PathSegment[])[]): unknown;

package/dist/server/variables/record-projection.js

@@ -0,0 +1,140 @@
+/**
+ * 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_projection_exports = {};
+__export(record_projection_exports, {
+  projectRecord: () => projectRecord
+});
+module.exports = __toCommonJS(record_projection_exports);
+const blockedKeys = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+const omitted = Symbol("omitted record projection value");
+function createNode() {
+  return { whole: false, children: /* @__PURE__ */ new Map() };
+}
+function isValidSegment(segment) {
+  return typeof segment === "string" ? !blockedKeys.has(segment) : Number.isInteger(segment) && segment >= 0 && segment < 2 ** 32 - 1;
+}
+function addPath(root, path) {
+  if (!path.every(isValidSegment)) return;
+  let node = root;
+  for (const segment of path) {
+    if (node.whole) return;
+    let child = node.children.get(segment);
+    if (!child) {
+      child = createNode();
+      node.children.set(segment, child);
+    }
+    node = child;
+  }
+  node.whole = true;
+  node.children.clear();
+}
+function mergeNodes(left, right) {
+  if (left.whole || right.whole) return { whole: true, children: /* @__PURE__ */ new Map() };
+  const merged = createNode();
+  for (const [segment, child] of left.children) merged.children.set(segment, child);
+  for (const [segment, child] of right.children) {
+    const existing = merged.children.get(segment);
+    merged.children.set(segment, existing ? mergeNodes(existing, child) : child);
+  }
+  return merged;
+}
+function getOwnDataProperty(source, key) {
+  const descriptor = Object.getOwnPropertyDescriptor(source, key);
+  if (!(descriptor == null ? void 0 : descriptor.enumerable) || !("value" in descriptor) || typeof descriptor.value === "function") return;
+  return descriptor;
+}
+function defineDataProperty(target, key, value) {
+  Object.defineProperty(target, key, { configurable: true, enumerable: true, value, writable: true });
+}
+function copyWhole(value, seen) {
+  if (typeof value === "function") return omitted;
+  if (!value || typeof value !== "object") return value;
+  if (value instanceof Date) return new Date(value.getTime());
+  if (Buffer.isBuffer(value)) return Buffer.prototype.toJSON.call(value);
+  const cached = seen.get(value);
+  if (cached) return cached;
+  const result = Array.isArray(value) ? new Array(value.length) : /* @__PURE__ */ Object.create(null);
+  seen.set(value, result);
+  for (const key of Object.keys(value)) {
+    if (blockedKeys.has(key)) continue;
+    const descriptor = getOwnDataProperty(value, key);
+    if (!descriptor) continue;
+    const child = copyWhole(descriptor.value, seen);
+    if (child !== omitted) defineDataProperty(result, key, child);
+  }
+  return result;
+}
+function projectArray(source, node) {
+  const elementNode = createNode();
+  const exactNodes = /* @__PURE__ */ new Map();
+  for (const [segment, child] of node.children) {
+    if (typeof segment === "string") elementNode.children.set(segment, child);
+    else exactNodes.set(segment, child);
+  }
+  const projectAllElements = elementNode.children.size > 0;
+  const result = projectAllElements ? new Array(source.length) : [];
+  const indices = new Set(exactNodes.keys());
+  if (projectAllElements) {
+    for (const key of Object.keys(source)) {
+      const index = Number(key);
+      if (String(index) === key && isValidSegment(index)) indices.add(index);
+    }
+  }
+  for (const index of indices) {
+    const descriptor = getOwnDataProperty(source, String(index));
+    if (!descriptor) continue;
+    const exactNode = exactNodes.get(index);
+    const childNode = exactNode && projectAllElements ? mergeNodes(elementNode, exactNode) : exactNode || elementNode;
+    const child = projectValue(descriptor.value, childNode);
+    if (child !== omitted) defineDataProperty(result, String(index), child);
+  }
+  return result;
+}
+function projectValue(value, node) {
+  if (node.whole) return copyWhole(value, /* @__PURE__ */ new WeakMap());
+  if (Array.isArray(value)) return projectArray(value, node);
+  if (!value || typeof value !== "object") return omitted;
+  const result = /* @__PURE__ */ Object.create(null);
+  for (const [segment, childNode] of node.children) {
+    if (typeof segment !== "string") continue;
+    const descriptor = getOwnDataProperty(value, segment);
+    if (!descriptor) continue;
+    const child = projectValue(descriptor.value, childNode);
+    if (child !== omitted) defineDataProperty(result, segment, child);
+  }
+  return result;
+}
+function projectRecord(raw, exposedPaths) {
+  const root = createNode();
+  for (const path of exposedPaths) addPath(root, path);
+  const result = projectValue(raw, root);
+  return result === omitted ? void 0 : result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  projectRecord
+});