@nocobase/flow-engine 2.0.0-alpha.2

package/lib/components/variables/utils.js

@@ -0,0 +1,177 @@
+/**
+ * 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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 utils_exports = {};
+__export(utils_exports, {
+  buildContextSelectorItems: () => buildContextSelectorItems,
+  createDefaultConverters: () => createDefaultConverters,
+  createFinalConverters: () => createFinalConverters,
+  formatPathToValue: () => formatPathToValue,
+  isVariableValue: () => isVariableValue,
+  loadMetaTreeChildren: () => loadMetaTreeChildren,
+  parseValueToPath: () => parseValueToPath,
+  preloadContextSelectorPath: () => preloadContextSelectorPath,
+  searchInLoadedNodes: () => searchInLoadedNodes
+});
+module.exports = __toCommonJS(utils_exports);
+var import_utils = require("../../utils");
+const parseValueToPath = /* @__PURE__ */ __name((value) => {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  const variableRegex = /^\{\{\s*ctx(?:\.(.+?))?\s*\}\}$/;
+  const match = trimmed.match(variableRegex);
+  if (!match) return void 0;
+  const pathString = match[1];
+  if (!pathString) return [];
+  return pathString.split(".");
+}, "parseValueToPath");
+const formatPathToValue = /* @__PURE__ */ __name((item) => {
+  const path = (item == null ? void 0 : item.paths) || [];
+  if (path.length === 0) return "{{ ctx }}";
+  return `{{ ctx.${path.join(".")} }}`;
+}, "formatPathToValue");
+const loadMetaTreeChildren = /* @__PURE__ */ __name(async (metaNode) => {
+  if (!(metaNode == null ? void 0 : metaNode.children)) return [];
+  if (typeof metaNode.children === "function") {
+    try {
+      return await metaNode.children();
+    } catch (error) {
+      console.warn(`Failed to load children for ${metaNode.name}:`, error);
+      return [];
+    }
+  }
+  return metaNode.children;
+}, "loadMetaTreeChildren");
+const searchInLoadedNodes = /* @__PURE__ */ __name((options, searchText, parentPaths = []) => {
+  if (!searchText || !searchText.trim()) return [];
+  const lowerSearchText = searchText.toLowerCase().trim();
+  const results = [];
+  const searchRecursive = /* @__PURE__ */ __name((nodes, currentPath = []) => {
+    var _a;
+    for (const node of nodes) {
+      const nodePath = [...currentPath, node.value];
+      const labelText = typeof node.label === "string" ? node.label : typeof ((_a = node.meta) == null ? void 0 : _a.title) === "string" ? node.meta.title : String(node.value);
+      if (labelText.toLowerCase().includes(lowerSearchText)) {
+        results.push(node);
+      }
+      if (node.children && Array.isArray(node.children)) {
+        searchRecursive(node.children, nodePath);
+      }
+    }
+  }, "searchRecursive");
+  searchRecursive(options, []);
+  return results;
+}, "searchInLoadedNodes");
+const buildContextSelectorItems = /* @__PURE__ */ __name((metaTree) => {
+  if (!metaTree || !Array.isArray(metaTree)) {
+    console.warn("buildContextSelectorItems received invalid metaTree:", metaTree);
+    return [];
+  }
+  const convertNode = /* @__PURE__ */ __name((node) => {
+    const hasChildren = !!(node.children && (typeof node.children === "function" || Array.isArray(node.children) && node.children.length > 0));
+    const disabled = !!(typeof node.disabled === "function" ? node.disabled() : node.disabled);
+    const option = {
+      label: node.title || node.name,
+      value: node.name,
+      isLeaf: !hasChildren,
+      meta: node,
+      paths: node.paths,
+      disabled
+    };
+    if (Array.isArray(node.children) && node.children.length > 0) {
+      option.children = node.children.map((child) => convertNode(child));
+    }
+    return option;
+  }, "convertNode");
+  return metaTree.map((node) => convertNode(node));
+}, "buildContextSelectorItems");
+const preloadContextSelectorPath = /* @__PURE__ */ __name(async (options, pathSegments, triggerUpdate) => {
+  if (!options || !Array.isArray(options) || !pathSegments || pathSegments.length === 0) return;
+  let list = options;
+  for (let i = 0; i < pathSegments.length && list; i++) {
+    const seg = String(pathSegments[i]);
+    const opt = list.find((o) => String(o.value) === seg);
+    if (!opt) break;
+    const meta = opt.meta;
+    const hasLoaded = !!opt.children && Array.isArray(opt.children);
+    if (i < pathSegments.length - 1 && !hasLoaded && meta && typeof meta.children === "function") {
+      opt.loading = true;
+      try {
+        const childNodes = await loadMetaTreeChildren(meta);
+        meta.children = childNodes;
+        const childOptions = buildContextSelectorItems(childNodes);
+        opt.children = childOptions;
+        opt.isLeaf = !childOptions || childOptions.length === 0;
+        Promise.resolve().then(() => triggerUpdate == null ? void 0 : triggerUpdate()).catch(() => {
+        });
+      } finally {
+        opt.loading = false;
+      }
+    }
+    list = Array.isArray(opt.children) ? opt.children : void 0;
+  }
+}, "preloadContextSelectorPath");
+const isVariableValue = /* @__PURE__ */ __name((value) => {
+  return (0, import_utils.isVariableExpression)(value);
+}, "isVariableValue");
+const createDefaultConverters = /* @__PURE__ */ __name(() => {
+  return {
+    resolvePathFromValue: /* @__PURE__ */ __name((value) => {
+      return parseValueToPath(value);
+    }, "resolvePathFromValue"),
+    resolveValueFromPath: /* @__PURE__ */ __name((item) => {
+      return formatPathToValue(item);
+    }, "resolveValueFromPath")
+  };
+}, "createDefaultConverters");
+const createFinalConverters = /* @__PURE__ */ __name((propConverters) => {
+  const defaultConverters = createDefaultConverters();
+  const mergedConverters = propConverters ? { ...defaultConverters, ...propConverters } : defaultConverters;
+  if (propConverters == null ? void 0 : propConverters.resolveValueFromPath) {
+    const customResolveValueFromPath = propConverters.resolveValueFromPath;
+    return {
+      ...mergedConverters,
+      resolveValueFromPath: /* @__PURE__ */ __name((item) => {
+        const ret = customResolveValueFromPath(item);
+        return ret === void 0 ? formatPathToValue(item) : ret;
+      }, "resolveValueFromPath")
+    };
+  }
+  return mergedConverters;
+}, "createFinalConverters");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildContextSelectorItems,
+  createDefaultConverters,
+  createFinalConverters,
+  formatPathToValue,
+  isVariableValue,
+  loadMetaTreeChildren,
+  parseValueToPath,
+  preloadContextSelectorPath,
+  searchInLoadedNodes
+});

package/lib/data-source/index.d.ts

@@ -0,0 +1,180 @@
+/**
+ * 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 _ from 'lodash';
+import { FlowEngine } from '../flowEngine';
+import { jioToJoiSchema } from './jioToJoiSchema';
+export interface DataSourceOptions extends Record<string, any> {
+    key: string;
+    displayName?: string;
+    description?: string;
+    [key: string]: any;
+}
+export declare class DataSourceManager {
+    dataSources: Map<string, DataSource>;
+    flowEngine: FlowEngine;
+    constructor();
+    setFlowEngine(flowEngine: FlowEngine): void;
+    addDataSource(ds: DataSource | DataSourceOptions): void;
+    upsertDataSource(ds: DataSource | DataSourceOptions): void;
+    removeDataSource(key: string): void;
+    clearDataSources(): void;
+    getDataSources(): DataSource[];
+    getDataSource(key: string): DataSource | undefined;
+    getCollection(dataSourceKey: string, collectionName: string): Collection | undefined;
+    getCollectionField(fieldPathWithDataSource: string): CollectionField;
+}
+export declare class DataSource {
+    dataSourceManager: DataSourceManager;
+    collectionManager: CollectionManager;
+    options: Record<string, any>;
+    constructor(options?: Record<string, any>);
+    get flowEngine(): FlowEngine;
+    get displayName(): any;
+    get key(): any;
+    get name(): any;
+    setDataSourceManager(dataSourceManager: DataSourceManager): void;
+    getCollections(): Collection[];
+    getCollection(name: string): Collection | undefined;
+    /**
+     * @deprecated use getAssociation instead
+     */
+    getAssocation(associationName: string): CollectionField | undefined;
+    getAssociation(associationName: string): CollectionField | undefined;
+    addCollection(collection: Collection | CollectionOptions): void;
+    updateCollection(newOptions: CollectionOptions): void;
+    upsertCollection(options: CollectionOptions): Collection;
+    upsertCollections(collections: CollectionOptions[]): void;
+    removeCollection(name: string): void;
+    clearCollections(): void;
+    setOptions(newOptions?: any): void;
+    getCollectionField(fieldPath: string): CollectionField;
+}
+export interface CollectionOptions {
+    name: string;
+    title?: string;
+    inherits?: string[];
+    [key: string]: any;
+}
+export declare class CollectionManager {
+    dataSource: DataSource;
+    collections: Map<string, Collection>;
+    constructor(dataSource: DataSource);
+    get flowEngine(): FlowEngine;
+    addCollection(collection: Collection | CollectionOptions): void;
+    removeCollection(name: string): void;
+    updateCollection(newOptions: CollectionOptions): void;
+    upsertCollection(options: CollectionOptions): Collection;
+    upsertCollections(collections: CollectionOptions[]): void;
+    sortCollectionsByInherits(collections: CollectionOptions[]): CollectionOptions[];
+    getCollection(name: string): Collection | undefined;
+    getCollections(): Collection[];
+    clearCollections(): void;
+    getAssociation(associationName: string): CollectionField | undefined;
+}
+export declare class Collection {
+    fields: Map<string, CollectionField>;
+    options: Record<string, any>;
+    inherits: Map<string, Collection>;
+    dataSource: DataSource;
+    constructor(options?: Record<string, any>);
+    getFilterByTK(record: any): any;
+    get hidden(): any;
+    get flowEngine(): FlowEngine;
+    get collectionManager(): CollectionManager;
+    get sort(): any;
+    get filterTargetKey(): any;
+    get dataSourceKey(): any;
+    get name(): any;
+    get template(): any;
+    get storage(): any;
+    get title(): any;
+    get titleCollectionField(): CollectionField;
+    initInherits(): void;
+    setDataSource(dataSource: DataSource): void;
+    setOptions(newOptions?: any): void;
+    getFields(): CollectionField[];
+    getToOneAssociationFields(): CollectionField[];
+    getAssociationFields(types?: any[]): CollectionField[];
+    mapFields(callback: (field: CollectionField) => any): any[];
+    setFields(fields: CollectionField[] | Record<string, any>[]): void;
+    upsertFields(fields?: Record<string, any>[]): void;
+    getFieldByPath(fieldPath: string): CollectionField | undefined;
+    getField(fieldName: string): CollectionField | undefined;
+    getFullFieldPath(name: string): string;
+    addField(field: CollectionField | Record<string, any>): void;
+    removeField(fieldName: string): boolean;
+    clearFields(): void;
+    refresh(): void;
+    /**
+     * 获取所有关联字段
+     * @returns 关联字段数组
+     */
+    getRelationshipFields(): CollectionField[];
+    /**
+     * 获取所有关联的集合
+     * @returns 关联集合数组
+     */
+    getRelatedCollections(): Collection[];
+    /**
+     * 检查是否有关联字段
+     * @returns 是否有关联字段
+     */
+    hasRelationshipFields(): boolean;
+}
+export declare class CollectionField {
+    options: Record<string, any>;
+    collection: Collection;
+    constructor(options: Record<string, any>);
+    setOptions(newOptions?: any): void;
+    setCollection(collection: Collection): void;
+    get targetCollectionTitleFieldName(): any;
+    get targetCollectionTitleField(): CollectionField;
+    get flowEngine(): FlowEngine;
+    get dataSourceKey(): any;
+    get resourceName(): string;
+    get collectionName(): any;
+    get readonly(): any;
+    get fullpath(): string;
+    get name(): any;
+    get type(): any;
+    get dataType(): any;
+    get foreignKey(): any;
+    get targetKey(): any;
+    get sourceKey(): any;
+    get target(): any;
+    get title(): string;
+    set title(value: string);
+    get enum(): any[];
+    get defaultValue(): any;
+    get interface(): any;
+    get filterable(): any;
+    get inputable(): any;
+    get uiSchema(): any;
+    get targetCollection(): Collection;
+    get validation(): any;
+    getComponentProps(): _.Dictionary<any>;
+    getFields(): CollectionField[];
+    getInterfaceOptions(): any;
+    getFilterOperators(): any;
+    getSubclassesOf(baseClass: string): Map<string, import("..").ModelConstructor>;
+    getFirstSubclassNameOf(baseClass: string): string;
+    isAssociationField(): boolean;
+    /**
+     * 检查字段是否为关联字段
+     * @returns 是否为关联字段
+     */
+    isRelationshipField(): boolean;
+}
+/**
+ * 判断 fieldInterfaces 是否匹配 targetInterface
+ * @param fieldInterfaces string | string[] | null
+ * @param targetInterface string
+ */
+export declare function isFieldInterfaceMatch(fieldInterfaces: string | string[] | null | undefined, targetInterface: string): boolean;
+export { jioToJoiSchema };