@nocobase/plugin-flow-engine 2.1.0-beta.2 → 2.1.0-beta.20

package/dist/server/flow-surfaces/service-helpers.js

@@ -0,0 +1,310 @@
+/**
+ * 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 __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 service_helpers_exports = {};
+__export(service_helpers_exports, {
+  buildCatalogCollectionCycleKey: () => buildCatalogCollectionCycleKey,
+  buildFilterFieldMeta: () => buildFilterFieldMeta,
+  buildFlowTemplateSearchFilter: () => buildFlowTemplateSearchFilter,
+  dedupeVisibleFieldCandidates: () => dedupeVisibleFieldCandidates,
+  getAssociationFilterTargetKey: () => getAssociationFilterTargetKey,
+  getCollectionFields: () => getCollectionFields,
+  getCollectionName: () => getCollectionName,
+  getCollectionTitle: () => getCollectionTitle,
+  getCollectionTitleFieldName: () => getCollectionTitleFieldName,
+  getFieldFilterable: () => getFieldFilterable,
+  getFieldInterface: () => getFieldInterface,
+  getFieldName: () => getFieldName,
+  getFieldTarget: () => getFieldTarget,
+  getFieldTitle: () => getFieldTitle,
+  getFieldType: () => getFieldType,
+  hasConfiguredFlowContextValue: () => hasConfiguredFlowContextValue,
+  inferAssociationLeafDisplayFieldUse: () => inferAssociationLeafDisplayFieldUse,
+  inferFieldMenuEditableFieldUse: () => inferFieldMenuEditableFieldUse,
+  inferFlowContextTypeFromField: () => inferFlowContextTypeFromField,
+  isAssociationField: () => isAssociationField,
+  normalizeFieldPath: () => normalizeFieldPath,
+  normalizeTemplatePage: () => normalizeTemplatePage,
+  normalizeTemplatePageSize: () => normalizeTemplatePageSize,
+  resolveAssociationNameFromField: () => resolveAssociationNameFromField,
+  resolveFieldFromCollection: () => resolveFieldFromCollection,
+  resolveFieldTargetCollection: () => resolveFieldTargetCollection,
+  toTemplatePlainRow: () => toTemplatePlainRow
+});
+module.exports = __toCommonJS(service_helpers_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_core_field_default_bindings = require("./core-field-default-bindings");
+const FLOW_SURFACE_TEMPLATE_DEFAULT_PAGE = 1;
+const FLOW_SURFACE_TEMPLATE_DEFAULT_PAGE_SIZE = 50;
+function toTemplatePlainRow(row) {
+  if (!row) {
+    return row;
+  }
+  if (typeof row.toJSON === "function") {
+    return row.toJSON();
+  }
+  return row;
+}
+function buildFlowTemplateSearchFilter(existing, search) {
+  const filters = [];
+  if (existing) {
+    filters.push(existing);
+  }
+  const normalizedSearch = String(search || "").trim();
+  if (normalizedSearch) {
+    filters.push({
+      $or: [{ name: { $includes: normalizedSearch } }, { description: { $includes: normalizedSearch } }]
+    });
+  }
+  if (!filters.length) {
+    return void 0;
+  }
+  if (filters.length === 1) {
+    return filters[0];
+  }
+  return { $and: filters };
+}
+function normalizeTemplatePage(value) {
+  const num = Number(value || FLOW_SURFACE_TEMPLATE_DEFAULT_PAGE);
+  if (!Number.isFinite(num) || num < 1) {
+    return FLOW_SURFACE_TEMPLATE_DEFAULT_PAGE;
+  }
+  return Math.floor(num);
+}
+function normalizeTemplatePageSize(value) {
+  const num = Number(value || FLOW_SURFACE_TEMPLATE_DEFAULT_PAGE_SIZE);
+  if (!Number.isFinite(num) || num < 1) {
+    return FLOW_SURFACE_TEMPLATE_DEFAULT_PAGE_SIZE;
+  }
+  return Math.floor(num);
+}
+function normalizeFieldPath(fieldPath, associationPathName) {
+  const normalizedFieldPath = String(fieldPath || "").trim();
+  const normalizedAssociationPath = String(associationPathName || "").trim();
+  if (!normalizedAssociationPath || !normalizedFieldPath || normalizedFieldPath.includes(".")) {
+    return normalizedFieldPath;
+  }
+  return `${normalizedAssociationPath}.${normalizedFieldPath}`;
+}
+function hasConfiguredFlowContextValue(value) {
+  return !import_lodash.default.isNil(value) && value !== "";
+}
+function buildFilterFieldMeta(field) {
+  return import_lodash.default.pickBy(
+    {
+      name: getFieldName(field),
+      title: getFieldTitle(field),
+      interface: getFieldInterface(field),
+      type: getFieldType(field)
+    },
+    (value) => !import_lodash.default.isUndefined(value)
+  );
+}
+function getCollectionFields(collection) {
+  var _a, _b, _c;
+  return import_lodash.default.castArray(((_a = collection == null ? void 0 : collection.getFields) == null ? void 0 : _a.call(collection)) || Array.from(((_c = (_b = collection == null ? void 0 : collection.fields) == null ? void 0 : _b.values) == null ? void 0 : _c.call(_b)) || []));
+}
+function getCollectionTitle(collection) {
+  var _a, _b;
+  return (collection == null ? void 0 : collection.title) || ((_a = collection == null ? void 0 : collection.options) == null ? void 0 : _a.title) || (collection == null ? void 0 : collection.name) || ((_b = collection == null ? void 0 : collection.options) == null ? void 0 : _b.name);
+}
+function getCollectionName(collection) {
+  var _a;
+  return (collection == null ? void 0 : collection.name) || ((_a = collection == null ? void 0 : collection.options) == null ? void 0 : _a.name);
+}
+function getCollectionTitleFieldName(collection) {
+  var _a, _b, _c, _d, _e;
+  const filterTargetKey = (collection == null ? void 0 : collection.filterTargetKey) || ((_a = collection == null ? void 0 : collection.options) == null ? void 0 : _a.filterTargetKey);
+  return ((_b = collection == null ? void 0 : collection.options) == null ? void 0 : _b.titleField) || ((_c = collection == null ? void 0 : collection.titleCollectionField) == null ? void 0 : _c.name) || ((_e = (_d = collection == null ? void 0 : collection.titleCollectionField) == null ? void 0 : _d.options) == null ? void 0 : _e.name) || (Array.isArray(filterTargetKey) ? filterTargetKey[0] : filterTargetKey) || (collection == null ? void 0 : collection.titleField);
+}
+function getFieldName(field) {
+  var _a;
+  return (field == null ? void 0 : field.name) || ((_a = field == null ? void 0 : field.options) == null ? void 0 : _a.name);
+}
+function getFieldTitle(field) {
+  var _a;
+  return (field == null ? void 0 : field.title) || ((_a = field == null ? void 0 : field.options) == null ? void 0 : _a.title) || getFieldName(field);
+}
+function resolveAssociationNameFromField(field, fallbackCollection) {
+  const resourceName = typeof (field == null ? void 0 : field.resourceName) === "string" ? field.resourceName.trim() : "";
+  if (resourceName) {
+    return resourceName;
+  }
+  const fieldName = getFieldName(field);
+  if (!fieldName) {
+    return void 0;
+  }
+  const sourceCollectionName = getCollectionName(field == null ? void 0 : field.collection) || getCollectionName(fallbackCollection);
+  return sourceCollectionName ? `${sourceCollectionName}.${fieldName}` : void 0;
+}
+function getFieldInterface(field) {
+  var _a;
+  return (field == null ? void 0 : field.interface) || ((_a = field == null ? void 0 : field.options) == null ? void 0 : _a.interface);
+}
+function getFieldType(field) {
+  var _a;
+  return (field == null ? void 0 : field.type) || ((_a = field == null ? void 0 : field.options) == null ? void 0 : _a.type);
+}
+function inferFlowContextTypeFromField(field) {
+  switch (getFieldType(field)) {
+    case "boolean":
+      return "boolean";
+    case "integer":
+    case "float":
+    case "double":
+    case "decimal":
+      return "number";
+    case "json":
+      return "object";
+    case "array":
+      return "array";
+    default:
+      return "string";
+  }
+}
+function getFieldTarget(field) {
+  var _a;
+  return (field == null ? void 0 : field.target) || ((_a = field == null ? void 0 : field.options) == null ? void 0 : _a.target);
+}
+function getFieldFilterable(field) {
+  var _a;
+  if (!import_lodash.default.isUndefined(field == null ? void 0 : field.filterable)) {
+    return field.filterable;
+  }
+  return (_a = field == null ? void 0 : field.options) == null ? void 0 : _a.filterable;
+}
+function inferAssociationLeafDisplayFieldUse(fieldInterface) {
+  return (0, import_core_field_default_bindings.getSharedFieldDefaultBindingUse)("display", fieldInterface);
+}
+function inferFieldMenuEditableFieldUse(fieldInterface) {
+  const normalized = String(fieldInterface || "").trim();
+  if (["m2m", "m2o", "o2o", "o2m", "oho", "obo", "updatedBy", "createdBy", "mbm"].includes(normalized)) {
+    return "RecordSelectFieldModel";
+  }
+  return (0, import_core_field_default_bindings.getSharedFieldDefaultBindingUse)("editable", normalized);
+}
+function isAssociationField(field) {
+  if (typeof (field == null ? void 0 : field.isAssociationField) === "function") {
+    return field.isAssociationField();
+  }
+  return ["belongsTo", "hasOne", "hasMany", "belongsToMany", "belongsToArray"].includes(getFieldType(field));
+}
+function resolveFieldFromCollection(collection, fieldPath) {
+  var _a, _b, _c;
+  if (!collection || !fieldPath) {
+    return null;
+  }
+  if (typeof (collection == null ? void 0 : collection.getFieldByPath) === "function") {
+    const direct = collection.getFieldByPath(fieldPath);
+    if (direct) {
+      return direct;
+    }
+  }
+  const [head, ...rest] = String(fieldPath || "").split(".").filter(Boolean);
+  const field = ((_a = collection == null ? void 0 : collection.getField) == null ? void 0 : _a.call(collection, head)) || ((_c = (_b = collection == null ? void 0 : collection.fields) == null ? void 0 : _b.get) == null ? void 0 : _c.call(_b, head));
+  if (!field || rest.length === 0) {
+    return field || null;
+  }
+  const targetCollection = resolveFieldTargetCollection(field, collection == null ? void 0 : collection.dataSourceKey, () => null);
+  if (!targetCollection) {
+    return null;
+  }
+  return resolveFieldFromCollection(targetCollection, rest.join("."));
+}
+function resolveFieldTargetCollection(field, dataSourceKey, getCollection) {
+  return (typeof (field == null ? void 0 : field.targetCollection) === "function" ? field.targetCollection() : field == null ? void 0 : field.targetCollection) || (getFieldTarget(field) ? getCollection(dataSourceKey || "main", getFieldTarget(field)) : null);
+}
+function buildCatalogCollectionCycleKey(collection, dataSourceKey) {
+  var _a;
+  if (!collection) {
+    return void 0;
+  }
+  return `${dataSourceKey || (collection == null ? void 0 : collection.dataSourceKey) || "main"}:${(collection == null ? void 0 : collection.name) || ((_a = collection == null ? void 0 : collection.options) == null ? void 0 : _a.name) || (collection == null ? void 0 : collection.title) || "unknown"}`;
+}
+function dedupeVisibleFieldCandidates(candidates) {
+  const seen = /* @__PURE__ */ new Set();
+  return candidates.filter((candidate) => {
+    const dedupeKey = [
+      normalizeFieldPath(candidate.fieldPath, candidate.associationPathName),
+      candidate.explicitWrapperUse || "",
+      candidate.explicitFieldUse || ""
+    ].join("::");
+    if (seen.has(dedupeKey)) {
+      return false;
+    }
+    seen.add(dedupeKey);
+    return true;
+  });
+}
+function getAssociationFilterTargetKey(field, targetCollection) {
+  var _a;
+  const resolvedTargetCollection = targetCollection || resolveFieldTargetCollection(field, "", () => null);
+  const filterTargetKey = (resolvedTargetCollection == null ? void 0 : resolvedTargetCollection.filterTargetKey) || ((_a = resolvedTargetCollection == null ? void 0 : resolvedTargetCollection.options) == null ? void 0 : _a.filterTargetKey);
+  if (Array.isArray(filterTargetKey)) {
+    return filterTargetKey[0] || "id";
+  }
+  return filterTargetKey || "id";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildCatalogCollectionCycleKey,
+  buildFilterFieldMeta,
+  buildFlowTemplateSearchFilter,
+  dedupeVisibleFieldCandidates,
+  getAssociationFilterTargetKey,
+  getCollectionFields,
+  getCollectionName,
+  getCollectionTitle,
+  getCollectionTitleFieldName,
+  getFieldFilterable,
+  getFieldInterface,
+  getFieldName,
+  getFieldTarget,
+  getFieldTitle,
+  getFieldType,
+  hasConfiguredFlowContextValue,
+  inferAssociationLeafDisplayFieldUse,
+  inferFieldMenuEditableFieldUse,
+  inferFlowContextTypeFromField,
+  isAssociationField,
+  normalizeFieldPath,
+  normalizeTemplatePage,
+  normalizeTemplatePageSize,
+  resolveAssociationNameFromField,
+  resolveFieldFromCollection,
+  resolveFieldTargetCollection,
+  toTemplatePlainRow
+});

package/dist/server/flow-surfaces/service-utils.d.ts

@@ -0,0 +1,108 @@
+/**
+ * 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 { FLOW_SURFACE_APPLY_BLUEPRINT_POPUP_DEFAULTS_KEY, type FlowSurfaceApplyBlueprintPopupDefaultsMetadata } from './blueprint/defaults';
+import type { FlowSurfaceNodeSpec, FlowSurfaceNodeSubModel } from './types';
+export declare function buildDefinedPayload(payload: Record<string, any>): _.Dictionary<any>;
+export declare function normalizeFlowSurfaceComposeKey(key: any, context: string): string;
+export declare function assertFlowSurfaceComposeUniqueKeys(items: Array<{
+    key?: string;
+}>, context: string): void;
+export declare function normalizeChartCardSettings(cardSettings: any): any;
+export declare function normalizeBlockTitleDescriptionValue(value: any): any;
+export declare function normalizeBlockTitleDescription(titleDescription: any): any;
+export declare function buildBlockTitleDescriptionFromSemanticChanges(changes: Record<string, any>): {
+    titleDescription: _.Dictionary<any>;
+};
+export declare function buildChartCardSettingsFromSemanticChanges(currentCardSettings: any, changes: Record<string, any>): any;
+export declare function buildPopupTabTree(options: {
+    tabUid?: string;
+    gridUid?: string;
+    title?: string;
+    icon?: string;
+    documentTitle?: string;
+    flowRegistry?: Record<string, any>;
+}): {
+    subModels: {
+        grid: {
+            uid: string;
+            use: string;
+        };
+    };
+    flowRegistry?: Record<string, any>;
+    uid: string;
+    use: string;
+    props: _.Dictionary<any>;
+    stepParams: {
+        pageTabSettings: {
+            tab: _.Dictionary<any>;
+        };
+    };
+};
+export declare function getSingleNodeSubModel(subModel?: FlowSurfaceNodeSubModel | null): FlowSurfaceNodeSpec | undefined;
+export declare function getNodeSubModelList(subModel?: FlowSurfaceNodeSubModel | null): FlowSurfaceNodeSpec[];
+export declare function flattenModel(node: any, carry?: Record<string, any>): Record<string, any>;
+export declare function buildDefaultFieldState(containerUse: string, fieldUse: string, field: any): {
+    wrapperProps: {};
+    fieldProps: Record<string, any>;
+};
+export declare function hasOwnDefined(input: Record<string, any>, key: string): boolean;
+export declare function hasMeaningfulChartSemanticPatch(input: Record<string, any>, key: string): boolean;
+export declare function hasDefinedValue(input: Record<string, any>, keys: string[]): boolean;
+export declare function ensureNoRawSimpleChangeKeys(changes: Record<string, any>): void;
+export declare function ensureNoRawDirectAddKeys(actionName: string, values: Record<string, any>, rawKeys: string[]): void;
+export declare function ensureNoDirectActionScopeKey(actionName: 'addAction' | 'addRecordAction', values: Record<string, any>): void;
+export type NormalizedComposeFieldSpec = {
+    index: number;
+    key: string;
+    fieldPath?: string;
+    associationPathName?: string;
+    renderer?: string;
+    type?: string;
+    target?: string;
+    settings: Record<string, any>;
+    popup?: Record<string, any>;
+    __autoPopupForRelationField?: boolean;
+    [FLOW_SURFACE_APPLY_BLUEPRINT_POPUP_DEFAULTS_KEY]?: FlowSurfaceApplyBlueprintPopupDefaultsMetadata;
+};
+export declare function normalizeComposeFieldSpec(input: any, index: number): NormalizedComposeFieldSpec;
+export declare function normalizeComposeActionSpec(input: any, index: number): {
+    popup?: any;
+    key: string;
+    type: string;
+    settings: any;
+};
+export declare function normalizeSimpleResourceInit(input: any): _.Dictionary<any>;
+export declare function isMissingRequiredResourceInitValue(value: any): boolean;
+export declare function joinRequiredFieldPaths(paths: string[]): string;
+export declare function normalizeSimpleLayoutValue(layout: any): any;
+export declare function normalizeGridCardColumns(columns: any): _.Dictionary<any>;
+export declare function normalizeSimpleConfirm(confirm: any): _.Dictionary<any>;
+export declare function assertSupportedSimpleChanges(context: string, changes: Record<string, any>, allowedKeys: string[]): void;
+export declare function hasLegacyLocatorFields(input: any, options?: {
+    allowRootUid?: boolean;
+}): boolean;
+export declare function rethrowInlineConfigurationError(error: any, prefix: string): never;
+export declare function toFlowSurfaceBatchItemError(error: any): {
+    code: string;
+    message: string;
+    status: number;
+    type: import("./errors").FlowSurfaceErrorType;
+};
+export declare function splitComposeFieldChanges(changes: Record<string, any>, wrapperUse?: string): {
+    wrapperChanges: _.Dictionary<any>;
+    fieldChanges: _.Dictionary<any>;
+};
+export declare function getCatalogRecordActionContainerUse(use?: string): "DetailsBlockModel" | "TableActionsColumnModel" | "ListItemModel" | "GridCardItemModel";
+export declare function normalizeRowSpans(spans?: Array<number | undefined>): number[];
+export declare function normalizePublicBlockHeightMode(input: any): string;
+export declare function normalizeStoredChartCardHeightMode(input: any): string;
+export declare function normalizeChartCardHeightModeForWrite(input: any): string;
+export declare function isFieldNodeUse(use?: string): boolean;
+export declare function getFieldBindingDefaultProps(containerUse: string, fieldUse: string, field: any): Record<string, any>;