@nocobase/flow-engine/lib/utils/createCollectionContextMeta.js

A standalone flow engine for NocoBase, managing workflows, models, and actions.

/**
 * 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 createCollectionContextMeta_exports = {};
__export(createCollectionContextMeta_exports, {
  createCollectionContextMeta: () => createCollectionContextMeta
});
module.exports = __toCommonJS(createCollectionContextMeta_exports);
const RELATION_FIELD_TYPES = ["belongsTo", "hasOne", "hasMany", "belongsToMany", "belongsToArray"];
const NUMERIC_FIELD_TYPES = ["integer", "float", "double", "decimal"];
function createFieldMetadata(field) {
  const baseProperties = createMetaBaseProperties(field);
  if (field.isAssociationField()) {
    const targetCollection = field.targetCollection;
    if (!targetCollection) {
      return {
        type: "object",
        ...baseProperties
      };
    }
    return {
      type: "object",
      // 所有关系字段统一使用 object 类型
      ...baseProperties,
      properties: /* @__PURE__ */ __name(async () => {
        const subProperties = {};
        targetCollection.fields.forEach((subField) => {
          subProperties[subField.name] = createFieldMetadata(subField);
        });
        return subProperties;
      }, "properties")
    };
  }
  return {
    type: getFieldType(field),
    ...baseProperties
  };
}
__name(createFieldMetadata, "createFieldMetadata");
function getFieldType(field) {
  const fieldType = field.type;
  if (RELATION_FIELD_TYPES.includes(fieldType)) {
    return "object";
  }
  if (NUMERIC_FIELD_TYPES.includes(fieldType)) {
    return "number";
  }
  switch (fieldType) {
    case "boolean":
      return "boolean";
    case "json":
      return "object";
    case "array":
      return "array";
    default:
      return "string";
  }
}
__name(getFieldType, "getFieldType");
function createMetaBaseProperties(field) {
  return {
    title: field.title || field.name,
    interface: field.interface,
    uiSchema: field.uiSchema || {}
  };
}
__name(createMetaBaseProperties, "createMetaBaseProperties");
function createCollectionContextMeta(collectionOrFactory, title) {
  const metaFn = /* @__PURE__ */ __name(async () => {
    const collection = typeof collectionOrFactory === "function" ? collectionOrFactory() : collectionOrFactory;
    if (!collection) {
      return null;
    }
    return {
      type: "object",
      title: title || collection.title || collection.name,
      properties: /* @__PURE__ */ __name(async () => {
        const properties = {};
        collection.fields.forEach((field) => {
          properties[field.name] = createFieldMetadata(field);
        });
        return properties;
      }, "properties")
    };
  }, "metaFn");
  metaFn.title = title;
  return metaFn;
}
__name(createCollectionContextMeta, "createCollectionContextMeta");
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  createCollectionContextMeta
});