@nocobase/flow-engine 2.0.0-alpha.2

package/lib/data-source/index.js

@@ -0,0 +1,733 @@
+/**
+ * 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 __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 __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 __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 data_source_exports = {};
+__export(data_source_exports, {
+  Collection: () => Collection,
+  CollectionField: () => CollectionField,
+  CollectionManager: () => CollectionManager,
+  DataSource: () => DataSource,
+  DataSourceManager: () => DataSourceManager,
+  isFieldInterfaceMatch: () => isFieldInterfaceMatch,
+  jioToJoiSchema: () => import_jioToJoiSchema.jioToJoiSchema
+});
+module.exports = __toCommonJS(data_source_exports);
+var import_reactive = require("@formily/reactive");
+var import_lodash = __toESM(require("lodash"));
+var import_jioToJoiSchema = require("./jioToJoiSchema");
+const _DataSourceManager = class _DataSourceManager {
+  dataSources;
+  flowEngine;
+  constructor() {
+    this.dataSources = import_reactive.observable.shallow(/* @__PURE__ */ new Map());
+  }
+  setFlowEngine(flowEngine) {
+    this.flowEngine = flowEngine;
+  }
+  addDataSource(ds) {
+    if (this.dataSources.has(ds.key)) {
+      throw new Error(`DataSource with name ${ds.key} already exists`);
+    }
+    if (ds instanceof DataSource) {
+      this.dataSources.set(ds.key, ds);
+    } else {
+      const clz = ds.use || DataSource;
+      ds = new clz(ds);
+      this.dataSources.set(ds.key, ds);
+    }
+    ds.setDataSourceManager(this);
+  }
+  upsertDataSource(ds) {
+    var _a;
+    if (this.dataSources.has(ds.key)) {
+      (_a = this.dataSources.get(ds.key)) == null ? void 0 : _a.setOptions(ds);
+    } else {
+      this.addDataSource(ds);
+    }
+  }
+  removeDataSource(key) {
+    this.dataSources.delete(key);
+  }
+  clearDataSources() {
+    this.dataSources.clear();
+  }
+  getDataSources() {
+    return Array.from(this.dataSources.values());
+  }
+  getDataSource(key) {
+    return this.dataSources.get(key);
+  }
+  getCollection(dataSourceKey, collectionName) {
+    const ds = this.getDataSource(dataSourceKey);
+    if (!ds) return void 0;
+    return ds.collectionManager.getCollection(collectionName);
+  }
+  getCollectionField(fieldPathWithDataSource) {
+    const [dataSourceKey, ...otherKeys] = fieldPathWithDataSource.split(".");
+    const ds = this.getDataSource(dataSourceKey);
+    if (!ds) return void 0;
+    return ds.getCollectionField(otherKeys.join("."));
+  }
+};
+__name(_DataSourceManager, "DataSourceManager");
+let DataSourceManager = _DataSourceManager;
+const _DataSource = class _DataSource {
+  dataSourceManager;
+  collectionManager;
+  options;
+  constructor(options = {}) {
+    this.options = (0, import_reactive.observable)({ ...options });
+    this.collectionManager = new CollectionManager(this);
+  }
+  get flowEngine() {
+    return this.dataSourceManager.flowEngine;
+  }
+  get displayName() {
+    return this.options.displayName ? this.flowEngine.translate(this.options.displayName) : this.key;
+  }
+  get key() {
+    return this.options.key;
+  }
+  get name() {
+    return this.options.key;
+  }
+  setDataSourceManager(dataSourceManager) {
+    this.dataSourceManager = dataSourceManager;
+  }
+  getCollections() {
+    return this.collectionManager.getCollections();
+  }
+  getCollection(name) {
+    return this.collectionManager.getCollection(name);
+  }
+  /**
+   * @deprecated use getAssociation instead
+   */
+  getAssocation(associationName) {
+    return this.getAssociation(associationName);
+  }
+  getAssociation(associationName) {
+    return this.collectionManager.getAssociation(associationName);
+  }
+  addCollection(collection) {
+    return this.collectionManager.addCollection(collection);
+  }
+  updateCollection(newOptions) {
+    return this.collectionManager.updateCollection(newOptions);
+  }
+  upsertCollection(options) {
+    return this.collectionManager.upsertCollection(options);
+  }
+  upsertCollections(collections) {
+    return this.collectionManager.upsertCollections(collections);
+  }
+  removeCollection(name) {
+    return this.collectionManager.removeCollection(name);
+  }
+  clearCollections() {
+    this.collectionManager.clearCollections();
+  }
+  setOptions(newOptions = {}) {
+    Object.keys(this.options).forEach((key) => delete this.options[key]);
+    Object.assign(this.options, newOptions);
+  }
+  getCollectionField(fieldPath) {
+    const [collectionName, ...otherKeys] = fieldPath.split(".");
+    const fieldName = otherKeys.join(".");
+    const collection = this.getCollection(collectionName);
+    if (!collection) {
+      throw new Error(`Collection ${collectionName} not found in data source ${this.key}`);
+    }
+    const field = collection.getFieldByPath(fieldName);
+    if (!field) {
+      return;
+    }
+    return field;
+  }
+};
+__name(_DataSource, "DataSource");
+let DataSource = _DataSource;
+const _CollectionManager = class _CollectionManager {
+  constructor(dataSource) {
+    this.dataSource = dataSource;
+    this.collections = import_reactive.observable.shallow(/* @__PURE__ */ new Map());
+  }
+  collections;
+  get flowEngine() {
+    return this.dataSource.flowEngine;
+  }
+  addCollection(collection) {
+    let col;
+    if (collection instanceof Collection) {
+      col = collection;
+    } else {
+      col = new Collection(collection);
+    }
+    col.setDataSource(this.dataSource);
+    col.initInherits();
+    this.collections.set(col.name, col);
+  }
+  removeCollection(name) {
+    this.collections.delete(name);
+  }
+  updateCollection(newOptions) {
+    const collection = this.getCollection(newOptions.name);
+    if (!collection) {
+      throw new Error(`Collection ${newOptions.name} not found`);
+    }
+    collection.setOptions(newOptions);
+  }
+  upsertCollection(options) {
+    if (this.collections.has(options.name)) {
+      this.updateCollection(options);
+    } else {
+      this.addCollection(options);
+    }
+    return this.getCollection(options.name);
+  }
+  upsertCollections(collections) {
+    for (const collection of this.sortCollectionsByInherits(collections)) {
+      if (this.collections.has(collection.name)) {
+        this.updateCollection(collection);
+      } else {
+        this.addCollection(collection);
+      }
+    }
+  }
+  sortCollectionsByInherits(collections) {
+    const map = /* @__PURE__ */ new Map();
+    for (const col of collections) {
+      map.set(col.name, col);
+    }
+    const graph = {};
+    const inDegree = {};
+    for (const col of collections) {
+      graph[col.name] = /* @__PURE__ */ new Set();
+      inDegree[col.name] = 0;
+    }
+    for (const col of collections) {
+      const inherits = col.inherits || [];
+      for (const parent of inherits) {
+        if (!graph[parent]) graph[parent] = /* @__PURE__ */ new Set();
+        graph[parent].add(col.name);
+        inDegree[col.name] = (inDegree[col.name] || 0) + 1;
+      }
+    }
+    const queue = [];
+    for (const name in inDegree) {
+      if (inDegree[name] === 0) queue.push(name);
+    }
+    const result = [];
+    while (queue.length) {
+      const curr = queue.shift();
+      if (map.has(curr)) {
+        result.push(map.get(curr));
+      }
+      for (const child of graph[curr] || []) {
+        inDegree[child]--;
+        if (inDegree[child] === 0) queue.push(child);
+      }
+    }
+    if (result.length !== collections.length) {
+      throw new Error("Collection inherits has circular dependency!");
+    }
+    return result;
+  }
+  getCollection(name) {
+    if (name.includes(".")) {
+      const [collectionName, fieldName] = name.split(".");
+      const collection = this.getCollection(collectionName);
+      if (!collection) {
+        throw new Error(`Collection ${collectionName} not found in data source ${this.dataSource.key}`);
+      }
+      const field = collection.getField(fieldName);
+      if (!field) {
+        throw new Error(`Field ${fieldName} not found in collection ${collectionName}`);
+      }
+      return field.targetCollection;
+    }
+    return this.collections.get(name);
+  }
+  getCollections() {
+    return import_lodash.default.sortBy(
+      Array.from(this.collections.values()).filter((collection) => !collection.hidden),
+      "sort"
+    );
+  }
+  clearCollections() {
+    this.collections.clear();
+  }
+  getAssociation(associationName) {
+    const [collectionName, fieldName] = associationName.split(".");
+    const collection = this.getCollection(collectionName);
+    if (!collection) {
+      throw new Error(`Collection ${collectionName} not found in data source ${this.dataSource.key}`);
+    }
+    return collection.getField(fieldName);
+  }
+};
+__name(_CollectionManager, "CollectionManager");
+let CollectionManager = _CollectionManager;
+const _Collection = class _Collection {
+  fields;
+  options;
+  inherits;
+  dataSource;
+  constructor(options = {}) {
+    this.options = (0, import_reactive.observable)({ ...options });
+    this.fields = import_reactive.observable.shallow(/* @__PURE__ */ new Map());
+    this.inherits = import_reactive.observable.shallow(/* @__PURE__ */ new Map());
+    this.setFields(options.fields || []);
+  }
+  getFilterByTK(record) {
+    if (!record) {
+      throw new Error("Record is required to get filterByTk");
+    }
+    if (Array.isArray(record)) {
+      return record.map((r) => this.getFilterByTK(r));
+    }
+    if (!this.filterTargetKey) {
+      throw new Error(`filterTargetKey is not defined for collection ${this.name}`);
+    }
+    if (typeof this.filterTargetKey === "string") {
+      return record[this.filterTargetKey];
+    }
+    return import_lodash.default.pick(record, this.filterTargetKey);
+  }
+  get hidden() {
+    return this.options.hidden || false;
+  }
+  get flowEngine() {
+    return this.dataSource.flowEngine;
+  }
+  get collectionManager() {
+    return this.dataSource.collectionManager;
+  }
+  get sort() {
+    return this.options.sort || 0;
+  }
+  get filterTargetKey() {
+    return this.options.filterTargetKey;
+  }
+  get dataSourceKey() {
+    return this.dataSource.key;
+  }
+  get name() {
+    return this.options.name;
+  }
+  get template() {
+    return this.options.template;
+  }
+  get storage() {
+    return this.options.storage || "local";
+  }
+  get title() {
+    return this.options.title ? this.flowEngine.translate(this.options.title) : this.name;
+  }
+  get titleCollectionField() {
+    const titleFieldName = this.options.titleField || this.filterTargetKey;
+    const titleCollectionField = this.getField(titleFieldName);
+    return titleCollectionField;
+  }
+  initInherits() {
+    this.inherits.clear();
+    for (const inherit of this.options.inherits || []) {
+      const collection = this.collectionManager.getCollection(inherit);
+      if (!collection) {
+        throw new Error(`Collection ${inherit} not found`);
+      }
+      this.inherits.set(inherit, collection);
+    }
+  }
+  setDataSource(dataSource) {
+    this.dataSource = dataSource;
+  }
+  setOptions(newOptions = {}) {
+    Object.keys(this.options).forEach((key) => delete this.options[key]);
+    Object.assign(this.options, newOptions);
+    this.initInherits();
+    this.upsertFields(this.options.fields || []);
+  }
+  getFields() {
+    const fieldMap = /* @__PURE__ */ new Map();
+    for (const inherit of this.inherits.values()) {
+      if (inherit && typeof inherit.getFields === "function") {
+        for (const field of inherit.getFields()) {
+          fieldMap.set(field.name, field);
+        }
+      }
+    }
+    for (const [name, field] of this.fields.entries()) {
+      fieldMap.set(name, field);
+    }
+    return Array.from(fieldMap.values());
+  }
+  getToOneAssociationFields() {
+    return this.getAssociationFields(["one"]);
+  }
+  getAssociationFields(types = []) {
+    if (types.includes("new")) {
+      return this.getFields().filter((field) => ["hasMany", "belongsToMany", "belongsToArray"].includes(field.type));
+    }
+    if (types.includes("many") && types.includes("one")) {
+      return this.getFields().filter((field) => field.isAssociationField());
+    }
+    if (types.includes("many")) {
+      return this.getFields().filter((field) => ["hasMany", "belongsToMany", "belongsToArray"].includes(field.type));
+    }
+    if (types.includes("one")) {
+      return this.getFields().filter((field) => ["hasOne", "belongsTo"].includes(field.type));
+    }
+    return this.getFields().filter((field) => field.isAssociationField());
+  }
+  mapFields(callback) {
+    return this.getFields().map(callback);
+  }
+  setFields(fields) {
+    this.fields.clear();
+    for (const field of fields) {
+      this.addField(field);
+    }
+  }
+  upsertFields(fields = []) {
+    for (const field of fields) {
+      if (this.fields.has(field.name)) {
+        this.fields.get(field.name).setOptions(field);
+      } else {
+        this.addField(field);
+      }
+    }
+  }
+  getFieldByPath(fieldPath) {
+    const [fieldName, ...otherKeys] = fieldPath.split(".");
+    const field = this.getField(fieldName);
+    if (otherKeys.length === 0) {
+      return field;
+    }
+    if (!field.targetCollection) {
+      return null;
+    }
+    return field.targetCollection.getFieldByPath(otherKeys.join("."));
+  }
+  getField(fieldName) {
+    return this.fields.get(fieldName);
+  }
+  getFullFieldPath(name) {
+    return this.dataSource.key + "." + this.name + "." + name;
+  }
+  addField(field) {
+    if (field.name && this.fields.has(field.name)) {
+      throw new Error(`Field with name ${field.name} already exists in collection ${this.name}`);
+    }
+    if (field instanceof CollectionField) {
+      field.setCollection(this);
+      this.fields.set(field.name, field);
+    } else {
+      const newField = new CollectionField(field);
+      newField.setCollection(this);
+      this.fields.set(newField.name, newField);
+    }
+  }
+  removeField(fieldName) {
+    return this.fields.delete(fieldName);
+  }
+  clearFields() {
+    return this.fields.clear();
+  }
+  refresh() {
+  }
+  /**
+   * 获取所有关联字段
+   * @returns 关联字段数组
+   */
+  getRelationshipFields() {
+    const relationshipInterfaces = [
+      "o2o",
+      "oho",
+      "obo",
+      "m2o",
+      "createdBy",
+      "updatedBy",
+      "o2m",
+      "m2m",
+      "linkTo",
+      "chinaRegion",
+      "mbm"
+    ];
+    return this.getFields().filter((field) => relationshipInterfaces.includes(field.interface));
+  }
+  /**
+   * 获取所有关联的集合
+   * @returns 关联集合数组
+   */
+  getRelatedCollections() {
+    const relationshipFields = this.getRelationshipFields();
+    const relatedCollections = [];
+    const addedCollectionNames = /* @__PURE__ */ new Set();
+    for (const field of relationshipFields) {
+      if (field.target && !addedCollectionNames.has(field.target)) {
+        const targetCollection = this.collectionManager.getCollection(field.target);
+        if (targetCollection && targetCollection.name !== this.name) {
+          relatedCollections.push(targetCollection);
+          addedCollectionNames.add(field.target);
+        }
+      }
+    }
+    return relatedCollections;
+  }
+  /**
+   * 检查是否有关联字段
+   * @returns 是否有关联字段
+   */
+  hasRelationshipFields() {
+    return this.getRelationshipFields().length > 0;
+  }
+};
+__name(_Collection, "Collection");
+let Collection = _Collection;
+const _CollectionField = class _CollectionField {
+  options;
+  collection;
+  constructor(options) {
+    this.options = (0, import_reactive.observable)({ ...options });
+  }
+  setOptions(newOptions = {}) {
+    Object.keys(this.options).forEach((key) => delete this.options[key]);
+    Object.assign(this.options, newOptions);
+  }
+  setCollection(collection) {
+    this.collection = collection;
+  }
+  get targetCollectionTitleFieldName() {
+    var _a, _b;
+    return (_b = (_a = this.targetCollection) == null ? void 0 : _a.titleCollectionField) == null ? void 0 : _b.name;
+  }
+  get targetCollectionTitleField() {
+    var _a;
+    return (_a = this.targetCollection) == null ? void 0 : _a.titleCollectionField;
+  }
+  get flowEngine() {
+    return this.collection.flowEngine;
+  }
+  get dataSourceKey() {
+    var _a;
+    return (_a = this.collection) == null ? void 0 : _a.dataSourceKey;
+  }
+  get resourceName() {
+    return `${this.collection.name}.${this.name}`;
+  }
+  get collectionName() {
+    var _a;
+    return ((_a = this.collection) == null ? void 0 : _a.name) || this.options.collectionName;
+  }
+  get readonly() {
+    var _a;
+    return this.options.readonly || ((_a = this.options.uiSchema) == null ? void 0 : _a["x-read-pretty"]) || false;
+  }
+  get fullpath() {
+    return this.collection.dataSource.key + "." + this.collection.name + "." + this.name;
+  }
+  get name() {
+    return this.options.name;
+  }
+  get type() {
+    return this.options.type;
+  }
+  get dataType() {
+    return this.options.dataType;
+  }
+  get foreignKey() {
+    return this.options.foreignKey;
+  }
+  get targetKey() {
+    return this.options.targetKey || this.targetCollection.filterTargetKey;
+  }
+  get sourceKey() {
+    return this.options.sourceKey;
+  }
+  get target() {
+    return this.options.target;
+  }
+  get title() {
+    var _a, _b, _c;
+    const titleValue = ((_a = this.options) == null ? void 0 : _a.title) || ((_c = (_b = this.options) == null ? void 0 : _b.uiSchema) == null ? void 0 : _c.title) || this.options.name;
+    return this.flowEngine.translate(titleValue);
+  }
+  set title(value) {
+    this.options.title = value;
+  }
+  get enum() {
+    var _a;
+    return ((_a = this.options.uiSchema) == null ? void 0 : _a.enum) || [];
+  }
+  get defaultValue() {
+    return this.options.defaultValue == null ? void 0 : this.options.defaultValue;
+  }
+  get interface() {
+    return this.options.interface;
+  }
+  get filterable() {
+    var _a;
+    return this.options.filterable || ((_a = this.getInterfaceOptions()) == null ? void 0 : _a.filterable);
+  }
+  get inputable() {
+    return this.options.inputable;
+  }
+  get uiSchema() {
+    return this.options.uiSchema || {};
+  }
+  get targetCollection() {
+    var _a;
+    return this.options.target && ((_a = this.collection) == null ? void 0 : _a.collectionManager.getCollection(this.options.target));
+  }
+  get validation() {
+    return this.options.validation;
+  }
+  getComponentProps() {
+    var _a;
+    const { type, target } = this.options;
+    const componentProps = import_lodash.default.omitBy(
+      {
+        ...import_lodash.default.omit(((_a = this.options.uiSchema) == null ? void 0 : _a["x-component-props"]) || {}, "fieldNames"),
+        options: this.enum.length ? this.enum : void 0,
+        mode: this.type === "array" ? "multiple" : void 0,
+        multiple: target ? ["belongsToMany", "hasMany", "belongsToArray"].includes(type) : void 0,
+        maxCount: target && !["belongsToMany", "hasMany", "belongsToArray"].includes(type) ? 1 : void 0,
+        target
+      },
+      import_lodash.default.isUndefined
+    );
+    if (this.validation) {
+      const rules = [];
+      const schema = (0, import_jioToJoiSchema.jioToJoiSchema)(this.validation);
+      const label = this.title;
+      rules.push({
+        validator: /* @__PURE__ */ __name((_2, value) => {
+          const { error } = schema.validate(value, {
+            context: { label },
+            abortEarly: false
+          });
+          if (error) {
+            const message = error.details.map((d) => d.message.replace(/"value"/g, `"${label}"`)).join(", ");
+            return Promise.reject(message);
+          }
+          return Promise.resolve();
+        }, "validator")
+      });
+      componentProps.rules = rules;
+    }
+    return componentProps;
+  }
+  getFields() {
+    if (!this.options.target) {
+      return [];
+    }
+    if (!this.targetCollection) {
+      throw new Error(`Target collection ${this.options.target} not found for field ${this.name}`);
+    }
+    return this.targetCollection.getFields();
+  }
+  getInterfaceOptions() {
+    const app = this.flowEngine.context.app;
+    return app.dataSourceManager.collectionFieldInterfaceManager.getFieldInterface(this.interface);
+  }
+  getFilterOperators() {
+    var _a;
+    const opts = this.getInterfaceOptions();
+    return ((_a = opts == null ? void 0 : opts.filterable) == null ? void 0 : _a.operators) || [];
+  }
+  getSubclassesOf(baseClass) {
+    return this.flowEngine.getSubclassesOf(baseClass, (M, name) => {
+      const interfaceMatch = isFieldInterfaceMatch(M["supportedFieldInterfaces"], this.interface);
+      return interfaceMatch;
+    });
+  }
+  getFirstSubclassNameOf(baseClass) {
+    const subclasses = this.getSubclassesOf(baseClass);
+    for (const [name, M] of subclasses) {
+      if (M["supportedFieldInterfaces"] !== "*") {
+        return name;
+      }
+    }
+    return void 0;
+  }
+  isAssociationField() {
+    return ["belongsToMany", "belongsTo", "hasMany", "hasOne", "belongsToArray"].includes(this.type);
+  }
+  /**
+   * 检查字段是否为关联字段
+   * @returns 是否为关联字段
+   */
+  isRelationshipField() {
+    const relationshipInterfaces = [
+      "o2o",
+      "oho",
+      "obo",
+      "m2o",
+      "createdBy",
+      "updatedBy",
+      "o2m",
+      "m2m",
+      "linkTo",
+      "chinaRegion",
+      "mbm"
+    ];
+    return relationshipInterfaces.includes(this.interface);
+  }
+};
+__name(_CollectionField, "CollectionField");
+let CollectionField = _CollectionField;
+function isFieldInterfaceMatch(fieldInterfaces, targetInterface) {
+  if (!fieldInterfaces) return false;
+  if (fieldInterfaces === "*") return true;
+  if (typeof fieldInterfaces === "string") return fieldInterfaces === targetInterface;
+  if (Array.isArray(fieldInterfaces)) {
+    return fieldInterfaces.includes("*") || fieldInterfaces.includes(targetInterface);
+  }
+  return false;
+}
+__name(isFieldInterfaceMatch, "isFieldInterfaceMatch");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Collection,
+  CollectionField,
+  CollectionManager,
+  DataSource,
+  DataSourceManager,
+  isFieldInterfaceMatch,
+  jioToJoiSchema
+});