@nocobase/flow-engine 2.1.0-alpha.10 → 2.1.0-alpha.11

package/src/__tests__/flow-engine.test.ts

@@ -89,7 +89,13 @@ describe('FlowEngine', () => {
     class MockFlowModelRepository implements IFlowModelRepository {
       // 使用可配置返回值，便于不同用例控制 findOne 行为
       findOneResult: any = null;
+      ensureResult: any = null;
+      ensureCalls = 0;
       save = vi.fn(async (model: FlowModel) => ({ success: true, uid: model.uid }));
+      async ensure() {
+        this.ensureCalls += 1;
+        return this.ensureResult ? JSON.parse(JSON.stringify(this.ensureResult)) : null;
+      }
       async findOne() {
         // 返回深拷贝，避免被测试过程修改
         return this.findOneResult ? JSON.parse(JSON.stringify(this.findOneResult)) : null;
@@ -188,5 +194,47 @@ describe('FlowEngine', () => {
       expect(Array.isArray(mounted)).toBe(false);
       expect(mounted?.uid).toBe('c3');
     });
+
+    it('should call repository.ensure with repository context preserved', async () => {
+      const parent = engine.createModel({ uid: 'p4', use: 'FlowModel' });
+
+      repo.ensureResult = {
+        uid: 'c4',
+        use: 'FlowModel',
+        parentId: parent.uid,
+        subKey: 'page',
+        subType: 'object',
+      };
+
+      const child = await engine.loadOrCreateModel({
+        parentId: parent.uid,
+        subKey: 'page',
+        subType: 'object',
+        use: 'FlowModel',
+        async: true,
+      });
+
+      expect(child).toBeTruthy();
+      expect(repo.ensureCalls).toBe(1);
+      expect((parent.subModels as any).page).toBe(child);
+      expect(repo.save).not.toHaveBeenCalled();
+    });
+
+    it('should not persist through ensure when skipSave is true', async () => {
+      repo.findOneResult = null;
+
+      const model = await engine.loadOrCreateModel(
+        {
+          uid: 'c5',
+          use: 'FlowModel',
+        },
+        { skipSave: true },
+      );
+
+      expect(model).toBeTruthy();
+      expect(model?.uid).toBe('c5');
+      expect(repo.ensureCalls).toBe(0);
+      expect(repo.save).not.toHaveBeenCalled();
+    });
   });
 });

package/src/__tests__/flowEngine.modelLoaders.test.ts

@@ -16,10 +16,14 @@ class MockFlowModelRepository implements IFlowModelRepository {
   findOneResult: any = null;
   save = vi.fn(async (model: FlowModel) => ({ success: true, uid: model.uid }));
 
-  async findOne() {
+  async findOne(_query?: any) {
     return this.findOneResult ? JSON.parse(JSON.stringify(this.findOneResult)) : null;
   }
 
+  async ensure(options: any) {
+    return await this.findOne(options);
+  }
+
   async destroy() {
     return true;
   }

package/src/__tests__/flowEngine.saveModel.test.ts

@@ -40,6 +40,10 @@ class MockFlowModelRepository implements IFlowModelRepository {
     return null;
   }
 
+  async ensure(options: any): Promise<any> {
+    return await this.findOne(options);
+  }
+
   async destroy(uid: string): Promise<boolean> {
     return true;
   }

package/src/__tests__/runjsContext.test.ts

@@ -38,6 +38,7 @@ describe('flowRunJSContext registry and doc', () => {
         'JSBlockModel',
         'JSFieldModel',
         'JSItemModel',
+        'JSItemActionModel',
         'JSColumnModel',
         'FormJSFieldItemModel',
         'JSRecordActionModel',
@@ -58,8 +59,10 @@ describe('flowRunJSContext registry and doc', () => {
     it('should expose scene metadata for contexts', () => {
       expect(getRunJSScenesForModel('JSBlockModel', 'v1')).toEqual(['block']);
       expect(getRunJSScenesForModel('JSFieldModel', 'v1')).toEqual(['detail']);
+      expect(getRunJSScenesForModel('JSItemActionModel', 'v1')).toEqual(['table']);
       expect(getRunJSScenesForModel('JSBlockModel', 'v2')).toEqual(['block']);
       expect(getRunJSScenesForModel('JSFieldModel', 'v2')).toEqual(['detail']);
+      expect(getRunJSScenesForModel('JSItemActionModel', 'v2')).toEqual(['table']);
       expect(getRunJSScenesForModel('UnknownModel', 'v1')).toEqual([]);
       expect(getRunJSScenesForModel('UnknownModel', 'v2')).toEqual([]);
     });

package/src/__tests__/runjsContextRuntime.test.ts

@@ -186,6 +186,7 @@ describe('RunJS Context Runtime Behavior', () => {
         'JSBlockModel',
         'JSFieldModel',
         'JSItemModel',
+        'JSItemActionModel',
         'JSColumnModel',
         'FormJSFieldItemModel',
         'JSRecordActionModel',
@@ -237,6 +238,7 @@ describe('RunJS Context Runtime Behavior', () => {
         'JSBlockModel',
         'JSFieldModel',
         'JSItemModel',
+        'JSItemActionModel',
         'JSColumnModel',
         'FormJSFieldItemModel',
         'JSRecordActionModel',

package/src/components/subModel/AddSubModelButton.tsx

@@ -9,7 +9,7 @@
 
 import { Switch } from 'antd';
 import _ from 'lodash';
-import React, { useMemo } from 'react';
+import React, { useEffect, useMemo } from 'react';
 import { FlowModelContext } from '../../flowContext';
 import { FlowModel } from '../../models';
 import { CreateModelOptions, ModelConstructor } from '../../types';
@@ -667,6 +667,20 @@ const AddSubModelButtonCore = function AddSubModelButton({
     [finalItems, model, subModelKey, subModelType],
   );
 
+  useEffect(() => {
+    const handleSubModelChange = () => {
+      setRefreshTick((x) => x + 1);
+    };
+
+    model.emitter.on('onSubModelAdded', handleSubModelChange);
+    model.emitter.on('onSubModelRemoved', handleSubModelChange);
+
+    return () => {
+      model.emitter.off('onSubModelAdded', handleSubModelChange);
+      model.emitter.off('onSubModelRemoved', handleSubModelChange);
+    };
+  }, [model]);
+
   return (
     <LazyDropdown
       menu={{

package/src/components/subModel/__tests__/AddSubModelButton.test.tsx

@@ -1117,6 +1117,7 @@ describe('AddSubModelButton toggleable behavior', () => {
   // Minimal fake repository for save/destroy
   class FakeRepo implements IFlowModelRepository<any> {
     findOne = vi.fn().mockResolvedValue(null);
+    ensure = vi.fn(async (values: any) => await this.findOne(values));
     save = vi.fn().mockResolvedValue({});
     destroy = vi.fn().mockResolvedValue(true);
     move = vi.fn().mockResolvedValue(undefined);

package/src/flow-schema-registry/fieldBinding.ts

@@ -0,0 +1,171 @@
+/**
+ * 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 type {
+  FlowFieldBindingConditions,
+  FlowFieldBindingContextContribution,
+  FlowFieldBindingContribution,
+  FlowFieldModelCompatibility,
+  FlowSchemaCoverage,
+} from '../types';
+import { normalizeStringArray } from './utils';
+
+export type RegisteredFieldBindingContext = {
+  name: string;
+  inherits: string[];
+};
+
+export type RegisteredFieldBinding = {
+  context: string;
+  use: string;
+  interfaces: string[];
+  isDefault: boolean;
+  order?: number;
+  conditions?: FlowFieldBindingConditions;
+  defaultProps?: any;
+  source: FlowSchemaCoverage['source'];
+};
+
+function normalizeFieldBindingConditions(
+  conditions?: FlowFieldBindingConditions,
+): FlowFieldBindingConditions | undefined {
+  if (!conditions || typeof conditions !== 'object' || Array.isArray(conditions)) {
+    return undefined;
+  }
+
+  const normalized = _.pickBy(
+    {
+      association: typeof conditions.association === 'boolean' ? conditions.association : undefined,
+      fieldTypes: normalizeStringArray(conditions.fieldTypes),
+      targetCollectionTemplateIn: normalizeStringArray(conditions.targetCollectionTemplateIn),
+      targetCollectionTemplateNotIn: normalizeStringArray(conditions.targetCollectionTemplateNotIn),
+    },
+    (value) => {
+      if (Array.isArray(value)) {
+        return value.length > 0;
+      }
+      return value !== undefined;
+    },
+  ) as FlowFieldBindingConditions;
+
+  return Object.keys(normalized).length > 0 ? normalized : undefined;
+}
+
+export function normalizeFieldBindingContextContribution(
+  contribution?: FlowFieldBindingContextContribution,
+  fallbackName?: string,
+): RegisteredFieldBindingContext | undefined {
+  const name = String(contribution?.name || fallbackName || '').trim();
+  if (!name) {
+    return undefined;
+  }
+
+  return {
+    name,
+    inherits: normalizeStringArray(contribution?.inherits),
+  };
+}
+
+export function normalizeFieldBindingContribution(
+  contribution?: FlowFieldBindingContribution,
+  source: FlowSchemaCoverage['source'] = 'official',
+): RegisteredFieldBinding | undefined {
+  const context = String(contribution?.context || '').trim();
+  const use = String(contribution?.use || '').trim();
+  const interfaces = normalizeStringArray(contribution?.interfaces);
+  if (!context || !use || interfaces.length === 0) {
+    return undefined;
+  }
+
+  return {
+    context,
+    use,
+    interfaces,
+    isDefault: contribution?.isDefault === true,
+    order: typeof contribution?.order === 'number' ? contribution.order : undefined,
+    conditions: normalizeFieldBindingConditions(contribution?.conditions),
+    defaultProps: contribution?.defaultProps === undefined ? undefined : _.cloneDeep(contribution.defaultProps),
+    source,
+  };
+}
+
+export function matchesFieldBinding(
+  binding: RegisteredFieldBinding,
+  options: {
+    interface?: string;
+    fieldType?: string;
+    association?: boolean;
+    targetCollectionTemplate?: string;
+  },
+) {
+  if (options.interface && !binding.interfaces.includes('*') && !binding.interfaces.includes(options.interface)) {
+    return false;
+  }
+
+  const conditions = binding.conditions;
+  if (!conditions) {
+    return true;
+  }
+
+  if (typeof conditions.association === 'boolean' && options.association !== undefined) {
+    if (conditions.association !== options.association) {
+      return false;
+    }
+  }
+
+  if (conditions.fieldTypes?.length && options.fieldType) {
+    if (!conditions.fieldTypes.includes(options.fieldType)) {
+      return false;
+    }
+  }
+
+  if (conditions.targetCollectionTemplateIn?.length && options.targetCollectionTemplate) {
+    if (!conditions.targetCollectionTemplateIn.includes(options.targetCollectionTemplate)) {
+      return false;
+    }
+  }
+
+  if (conditions.targetCollectionTemplateNotIn?.length && options.targetCollectionTemplate) {
+    if (conditions.targetCollectionTemplateNotIn.includes(options.targetCollectionTemplate)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+export function buildFieldModelCompatibility(binding: RegisteredFieldBinding): FlowFieldModelCompatibility {
+  const compatibility: FlowFieldModelCompatibility = {
+    context: binding.context,
+    interfaces: _.cloneDeep(binding.interfaces),
+    inheritParentFieldBinding: true,
+  };
+
+  if (binding.isDefault) {
+    compatibility.isDefault = true;
+  }
+  if (typeof binding.order === 'number') {
+    compatibility.order = binding.order;
+  }
+  if (typeof binding.conditions?.association === 'boolean') {
+    compatibility.association = binding.conditions.association;
+  }
+  if (binding.conditions?.fieldTypes?.length) {
+    compatibility.fieldTypes = _.cloneDeep(binding.conditions.fieldTypes);
+  }
+  if (binding.conditions?.targetCollectionTemplateIn?.length) {
+    compatibility.targetCollectionTemplateIn = _.cloneDeep(binding.conditions.targetCollectionTemplateIn);
+  }
+  if (binding.conditions?.targetCollectionTemplateNotIn?.length) {
+    compatibility.targetCollectionTemplateNotIn = _.cloneDeep(binding.conditions.targetCollectionTemplateNotIn);
+  }
+
+  return compatibility;
+}

package/src/flow-schema-registry/modelPatches.ts

@@ -0,0 +1,260 @@
+/**
+ * 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 type {
+  FlowDescendantSchemaPatch,
+  FlowJsonSchema,
+  FlowModelSchemaPatch,
+  FlowSchemaContextEdge,
+  FlowSchemaCoverage,
+  FlowSubModelContextPathStep,
+  FlowSubModelSlotSchema,
+} from '../types';
+import type { RegisteredModelSchema } from '../FlowSchemaRegistry';
+import { deepMergeReplaceArrays, mergeSchemas, normalizeSchemaDocs, normalizeSchemaHints } from './utils';
+
+export function normalizeSubModelContextPath(path?: FlowSubModelContextPathStep[]): FlowSubModelContextPathStep[] {
+  if (!Array.isArray(path)) {
+    return [];
+  }
+
+  return path
+    .map((step) => ({
+      slotKey: String(step?.slotKey || '').trim(),
+      ...(typeof step?.use === 'string'
+        ? { use: step.use.trim() }
+        : Array.isArray(step?.use)
+          ? { use: step.use.map((item) => String(item || '').trim()).filter(Boolean) }
+          : {}),
+    }))
+    .filter((step) => !!step.slotKey);
+}
+
+export function normalizeModelSchemaPatch(patch?: FlowModelSchemaPatch): FlowModelSchemaPatch | undefined {
+  if (!patch || typeof patch !== 'object' || Array.isArray(patch)) {
+    return undefined;
+  }
+
+  const normalized = _.pickBy(
+    {
+      stepParamsSchema: patch.stepParamsSchema ? _.cloneDeep(patch.stepParamsSchema) : undefined,
+      flowRegistrySchema: patch.flowRegistrySchema ? _.cloneDeep(patch.flowRegistrySchema) : undefined,
+      flowRegistrySchemaPatch: patch.flowRegistrySchemaPatch ? _.cloneDeep(patch.flowRegistrySchemaPatch) : undefined,
+      subModelSlots: normalizeSubModelSlots(patch.subModelSlots),
+      docs: patch.docs ? normalizeSchemaDocs(patch.docs) : undefined,
+      examples: Array.isArray(patch.examples) ? _.cloneDeep(patch.examples) : undefined,
+      skeleton: patch.skeleton === undefined ? undefined : _.cloneDeep(patch.skeleton),
+      dynamicHints: Array.isArray(patch.dynamicHints) ? normalizeSchemaHints(patch.dynamicHints) : undefined,
+    },
+    (value) => value !== undefined && (!Array.isArray(value) || value.length > 0),
+  ) as FlowModelSchemaPatch;
+
+  return Object.keys(normalized).length > 0 ? normalized : undefined;
+}
+
+function normalizeDescendantSchemaPatches(
+  patches?: FlowDescendantSchemaPatch[],
+): FlowDescendantSchemaPatch[] | undefined {
+  if (!Array.isArray(patches)) {
+    return undefined;
+  }
+
+  const normalized = patches
+    .map((item) => {
+      const path = normalizeSubModelContextPath(item?.path);
+      const patch = normalizeModelSchemaPatch(item?.patch);
+      if (!patch) {
+        return undefined;
+      }
+      return { path, patch };
+    })
+    .filter(Boolean) as FlowDescendantSchemaPatch[];
+
+  return normalized.length > 0 ? normalized : undefined;
+}
+
+function normalizeChildSchemaPatch(
+  patch?: FlowSubModelSlotSchema['childSchemaPatch'],
+): FlowSubModelSlotSchema['childSchemaPatch'] | undefined {
+  if (!patch || typeof patch !== 'object' || Array.isArray(patch)) {
+    return undefined;
+  }
+
+  const directPatch = normalizeModelSchemaPatch(patch as FlowModelSchemaPatch);
+  if (directPatch) {
+    return directPatch;
+  }
+
+  const entries = Object.entries(patch as Record<string, FlowModelSchemaPatch>)
+    .map(([childUse, childPatch]) => [String(childUse || '').trim(), normalizeModelSchemaPatch(childPatch)] as const)
+    .filter(([childUse, childPatch]) => !!childUse && !!childPatch);
+
+  if (!entries.length) {
+    return undefined;
+  }
+
+  return Object.fromEntries(entries);
+}
+
+export function normalizeSubModelSlots(
+  slots?: Record<string, FlowSubModelSlotSchema>,
+): Record<string, FlowSubModelSlotSchema> | undefined {
+  if (!slots || typeof slots !== 'object' || Array.isArray(slots)) {
+    return undefined;
+  }
+
+  const normalizedEntries = Object.entries(slots)
+    .map(([slotKey, slot]) => {
+      if (!slot?.type) {
+        return undefined;
+      }
+
+      const normalizedSlot: FlowSubModelSlotSchema = {
+        type: slot.type,
+      };
+
+      const normalizedUse = typeof slot.use === 'string' ? slot.use.trim() : undefined;
+      if (normalizedUse) {
+        normalizedSlot.use = normalizedUse;
+      }
+
+      const normalizedUses = Array.isArray(slot.uses)
+        ? slot.uses.map((item) => String(item || '').trim()).filter(Boolean)
+        : undefined;
+      if (normalizedUses?.length) {
+        normalizedSlot.uses = normalizedUses;
+      }
+
+      if (slot.required !== undefined) {
+        normalizedSlot.required = slot.required;
+      }
+      if (slot.type === 'array' && typeof slot.minItems === 'number' && Number.isFinite(slot.minItems)) {
+        normalizedSlot.minItems = Math.max(0, Math.trunc(slot.minItems));
+      }
+      if (slot.dynamic !== undefined) {
+        normalizedSlot.dynamic = slot.dynamic;
+      }
+      if (slot.schema) {
+        normalizedSlot.schema = _.cloneDeep(slot.schema);
+      }
+      if (typeof slot.fieldBindingContext === 'string' && slot.fieldBindingContext.trim()) {
+        normalizedSlot.fieldBindingContext = slot.fieldBindingContext.trim();
+      }
+
+      const childSchemaPatch = normalizeChildSchemaPatch(slot.childSchemaPatch);
+      if (childSchemaPatch) {
+        normalizedSlot.childSchemaPatch = childSchemaPatch;
+      }
+
+      const descendantSchemaPatches = normalizeDescendantSchemaPatches(slot.descendantSchemaPatches);
+      if (descendantSchemaPatches?.length) {
+        normalizedSlot.descendantSchemaPatches = descendantSchemaPatches;
+      }
+
+      if (slot.description !== undefined) {
+        normalizedSlot.description = slot.description;
+      }
+
+      return [slotKey, normalizedSlot] as const;
+    })
+    .filter(Boolean) as Array<readonly [string, FlowSubModelSlotSchema]>;
+
+  return normalizedEntries.length > 0 ? Object.fromEntries(normalizedEntries) : undefined;
+}
+
+export function matchesDescendantSchemaPatch(
+  patch: FlowDescendantSchemaPatch,
+  remainingEdges: FlowSchemaContextEdge[],
+): boolean {
+  const path = normalizeSubModelContextPath(patch.path);
+  if (path.length !== remainingEdges.length) {
+    return false;
+  }
+
+  return path.every((step, index) => {
+    const edge = remainingEdges[index];
+    if (step.slotKey !== edge.slotKey) {
+      return false;
+    }
+    if (typeof step.use === 'undefined') {
+      return true;
+    }
+    if (typeof step.use === 'string') {
+      return step.use === edge.childUse;
+    }
+    return step.use.includes(edge.childUse);
+  });
+}
+
+export function resolveChildSchemaPatch(
+  slot: FlowSubModelSlotSchema,
+  childUse: string,
+): FlowModelSchemaPatch | undefined {
+  const childSchemaPatch = slot.childSchemaPatch;
+  if (!childSchemaPatch || typeof childSchemaPatch !== 'object' || Array.isArray(childSchemaPatch)) {
+    return undefined;
+  }
+
+  const directPatch = normalizeModelSchemaPatch(childSchemaPatch as FlowModelSchemaPatch);
+  if (directPatch) {
+    return directPatch;
+  }
+
+  return normalizeModelSchemaPatch((childSchemaPatch as Record<string, FlowModelSchemaPatch>)[childUse]);
+}
+
+export function applyModelSchemaPatch(
+  target: RegisteredModelSchema,
+  patch: FlowModelSchemaPatch,
+  source: FlowSchemaCoverage['source'],
+  strict?: boolean,
+) {
+  target.stepParamsSchema = mergeSchemas(target.stepParamsSchema, patch.stepParamsSchema);
+  target.flowRegistrySchema = mergeSchemas(target.flowRegistrySchema, patch.flowRegistrySchema);
+  target.flowRegistrySchemaPatch = mergeSchemas(target.flowRegistrySchemaPatch, patch.flowRegistrySchemaPatch);
+  target.subModelSlots = normalizeSubModelSlots(
+    patch.subModelSlots
+      ? deepMergeReplaceArrays(target.subModelSlots || {}, patch.subModelSlots)
+      : target.subModelSlots,
+  );
+  target.docs = normalizeSchemaDocs({
+    ...target.docs,
+    ...patch.docs,
+    examples: patch.docs?.examples || target.docs?.examples,
+    dynamicHints: [...(target.docs?.dynamicHints || []), ...(patch.docs?.dynamicHints || [])],
+    commonPatterns: patch.docs?.commonPatterns || target.docs?.commonPatterns,
+    antiPatterns: patch.docs?.antiPatterns || target.docs?.antiPatterns,
+    minimalExample: patch.docs?.minimalExample !== undefined ? patch.docs.minimalExample : target.docs?.minimalExample,
+  });
+  target.examples = Array.isArray(patch.examples) ? _.cloneDeep(patch.examples) : target.examples;
+  target.skeleton =
+    patch.skeleton !== undefined ? deepMergeReplaceArrays(target.skeleton, patch.skeleton) : target.skeleton;
+  target.dynamicHints = normalizeSchemaHints([
+    ...(target.dynamicHints || []),
+    ...(patch.dynamicHints || []),
+    ...(patch.docs?.dynamicHints || []),
+  ]);
+
+  const hasSchemaPatch =
+    !!patch.stepParamsSchema || !!patch.flowRegistrySchema || !!patch.flowRegistrySchemaPatch || !!patch.subModelSlots;
+  if (hasSchemaPatch) {
+    target.coverage = {
+      ...target.coverage,
+      status:
+        target.coverage.status === 'unresolved'
+          ? 'manual'
+          : target.coverage.status === 'auto'
+            ? 'mixed'
+            : target.coverage.status,
+      source: target.coverage.source === 'third-party' ? source : target.coverage.source,
+      strict: target.coverage.strict ?? strict,
+    };
+  }
+}