@nocobase/flow-engine 2.1.0-alpha.2 → 2.1.0-alpha.20

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

@@ -189,4 +189,170 @@ describe('FlowEngine', () => {
       expect(mounted?.uid).toBe('c3');
     });
   });
+
+  describe('getSubclassesOfAsync', () => {
+    it('should return async-loaded subclasses matching extends declaration', async () => {
+      class AsyncSubModelD extends BaseModel {}
+      class AsyncSubModelE extends BaseModel {}
+
+      engine.registerModelLoaders({
+        AsyncSubModelD: {
+          extends: 'BaseModel',
+          loader: async () => ({ AsyncSubModelD }),
+        },
+        AsyncSubModelE: {
+          extends: 'BaseModel',
+          loader: async () => ({ AsyncSubModelE }),
+        },
+      });
+
+      const result = await engine.getSubclassesOfAsync(BaseModel);
+
+      // Sync-registered subclasses
+      expect(result.has('SubModelA')).toBe(true);
+      expect(result.has('SubModelB')).toBe(true);
+      expect(result.has('SubModelC')).toBe(true);
+      // Async-loaded subclasses
+      expect(result.has('AsyncSubModelD')).toBe(true);
+      expect(result.has('AsyncSubModelE')).toBe(true);
+      // Base class excluded
+      expect(result.has('BaseModel')).toBe(false);
+    });
+
+    it('should merge sync-registered and async-loaded subclasses', async () => {
+      class AsyncSubModel extends BaseModel {}
+
+      engine.registerModelLoaders({
+        AsyncSubModel: {
+          extends: 'BaseModel',
+          loader: async () => ({ AsyncSubModel }),
+        },
+      });
+
+      const result = await engine.getSubclassesOfAsync('BaseModel');
+
+      // Sync: SubModelA, SubModelB, SubModelC
+      expect(result.has('SubModelA')).toBe(true);
+      expect(result.has('SubModelB')).toBe(true);
+      expect(result.has('SubModelC')).toBe(true);
+      // Async
+      expect(result.has('AsyncSubModel')).toBe(true);
+      expect(result.size).toBe(4);
+    });
+
+    it('should support extends as string array (multiple parents)', async () => {
+      class AnotherBase extends FlowModel {}
+      class MultiParentModel extends BaseModel {}
+
+      engine.registerModels({ AnotherBase });
+      engine.registerModelLoaders({
+        MultiParentModel: {
+          extends: ['BaseModel', 'AnotherBase'],
+          loader: async () => ({ MultiParentModel }),
+        },
+      });
+
+      const resultBase = await engine.getSubclassesOfAsync(BaseModel);
+      expect(resultBase.has('MultiParentModel')).toBe(true);
+
+      // Also found by AnotherBase (even though actual inheritance is from BaseModel, not AnotherBase)
+      // The extends declaration triggers loading, but isInheritedFrom validation will exclude it from AnotherBase results
+      const resultAnother = await engine.getSubclassesOfAsync(AnotherBase);
+      expect(resultAnother.has('MultiParentModel')).toBe(false);
+    });
+
+    it('should support extends as ModelConstructor', async () => {
+      class AsyncCtorSubModel extends BaseModel {}
+
+      engine.registerModelLoaders({
+        AsyncCtorSubModel: {
+          extends: BaseModel,
+          loader: async () => ({ AsyncCtorSubModel }),
+        },
+      });
+
+      const result = await engine.getSubclassesOfAsync(BaseModel);
+      expect(result.has('AsyncCtorSubModel')).toBe(true);
+    });
+
+    it('should validate actual inheritance and warn on mismatch', async () => {
+      class UnrelatedModel extends FlowModel {}
+      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+      engine.registerModelLoaders({
+        UnrelatedModel: {
+          extends: 'BaseModel',
+          loader: async () => ({ UnrelatedModel }),
+        },
+      });
+
+      const result = await engine.getSubclassesOfAsync(BaseModel);
+      expect(result.has('UnrelatedModel')).toBe(false);
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringContaining("declares extends 'BaseModel' but does not actually inherit from it"),
+      );
+
+      warnSpy.mockRestore();
+    });
+
+    it('should resolve base class from loaders if not in _modelClasses', async () => {
+      const freshEngine = new FlowEngine();
+
+      class LazyBase extends FlowModel {}
+      class LazySub extends LazyBase {}
+
+      freshEngine.registerModelLoaders({
+        LazyBase: {
+          loader: async () => ({ LazyBase }),
+        },
+        LazySub: {
+          extends: 'LazyBase',
+          loader: async () => ({ LazySub }),
+        },
+      });
+
+      const result = await freshEngine.getSubclassesOfAsync('LazyBase');
+      expect(result.has('LazySub')).toBe(true);
+      expect(result.size).toBe(1);
+    });
+
+    it('should return empty Map when base class cannot be found', async () => {
+      const result = await engine.getSubclassesOfAsync('NonExistentModel');
+      expect(result.size).toBe(0);
+    });
+
+    it('should support filter parameter on both sync and async sources', async () => {
+      class FilteredAsyncModel extends BaseModel {}
+
+      engine.registerModelLoaders({
+        FilteredAsyncModel: {
+          extends: 'BaseModel',
+          loader: async () => ({ FilteredAsyncModel }),
+        },
+      });
+
+      const result = await engine.getSubclassesOfAsync(BaseModel, (_ModelClass, name) => name.startsWith('SubModelA'));
+
+      // Only SubModelA passes the filter (SubModelB, SubModelC, FilteredAsyncModel excluded)
+      expect(result.has('SubModelA')).toBe(true);
+      expect(result.has('SubModelB')).toBe(false);
+      expect(result.has('SubModelC')).toBe(false);
+      expect(result.has('FilteredAsyncModel')).toBe(false);
+    });
+
+    it('should not include loaders without extends declaration', async () => {
+      class NoExtendsModel extends BaseModel {}
+
+      engine.registerModelLoaders({
+        NoExtendsModel: {
+          loader: async () => ({ NoExtendsModel }),
+        },
+      });
+
+      const result = await engine.getSubclassesOfAsync(BaseModel);
+      // Only sync-registered subclasses; NoExtendsModel has no extends, so not discovered
+      expect(result.has('NoExtendsModel')).toBe(false);
+      expect(result.has('SubModelA')).toBe(true);
+    });
+  });
 });

package/src/__tests__/flowContext.test.ts

@@ -7,7 +7,8 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { describe, expect, it, vi } from 'vitest';
+import axios from 'axios';
+import { describe, expect, it, vi, afterEach } from 'vitest';
 import { FlowContext, FlowRuntimeContext, FlowRunJSContext, type PropertyMetaFactory } from '../flowContext';
 import { FlowEngine } from '../flowEngine';
 import { FlowModel } from '../models/flowModel';
@@ -1630,6 +1631,69 @@ describe('runAction delegation from runtime context', () => {
   });
 });
 
+describe('FlowContext request defaults', () => {
+  class RequestModel extends FlowModel {}
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  const createRequestContext = () => {
+    const engine = new FlowEngine();
+    engine.registerModels({ RequestModel });
+
+    const apiRequest = vi.fn(async (options) => options);
+    const app = {
+      getApiUrl(pathname = '') {
+        return 'https://app.example.com/api/'.replace(/\/$/g, '') + '/' + pathname.replace(/^\//g, '');
+      },
+    };
+
+    engine.context.defineProperty('api', { value: { request: apiRequest } as any });
+    engine.context.defineProperty('app', { value: app });
+
+    const model = engine.createModel({ use: 'RequestModel' });
+    const ctx = new FlowRuntimeContext(model, 'flow');
+    const directAxiosRequest = vi.spyOn(axios, 'request').mockResolvedValue({ data: {} } as any);
+
+    return { ctx, apiRequest, directAxiosRequest };
+  };
+
+  it.each([
+    ['apiClient', 'users:list', 'api'],
+    ['apiClient', '/api/users:list', 'api'],
+    ['apiClient', 'https://app.example.com/api/users:list', 'api'],
+    ['direct axios', 'https://app.example.com/custom-api/users', 'axios'],
+  ])('should use %s for %s', async (_target, url, expected) => {
+    const { ctx, apiRequest, directAxiosRequest } = createRequestContext();
+
+    await ctx.request({ url, method: 'get' });
+
+    if (expected === 'api') {
+      expect(apiRequest).toHaveBeenCalledTimes(1);
+      expect(directAxiosRequest).not.toHaveBeenCalled();
+      return;
+    }
+
+    expect(directAxiosRequest).toHaveBeenCalledTimes(1);
+    expect(apiRequest).not.toHaveBeenCalled();
+  });
+
+  it('should use direct axios for cross-origin absolute urls', async () => {
+    const { ctx, apiRequest, directAxiosRequest } = createRequestContext();
+
+    await ctx.request({ url: 'https://api.example.com/users', method: 'get', skipAuth: false });
+
+    expect(directAxiosRequest).toHaveBeenCalledTimes(1);
+    expect(apiRequest).not.toHaveBeenCalled();
+    expect(directAxiosRequest.mock.calls[0][0]).toMatchObject({
+      url: 'https://api.example.com/users',
+      method: 'get',
+      skipAuth: false,
+    });
+  });
+});
+
 describe('FlowContext delayed meta loading', () => {
   // 测试场景：属性定义时 meta 为异步函数，首次访问时延迟加载
   // 输入：属性带有异步 meta 函数

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

@@ -0,0 +1,245 @@
+/**
+ * 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 { beforeEach, describe, expect, it, vi } from 'vitest';
+import { FlowEngine } from '../flowEngine';
+import { ErrorFlowModel, FlowModel } from '../models';
+import type { IFlowModelRepository } from '../types';
+
+class MockFlowModelRepository implements IFlowModelRepository {
+  findOneResult: any = null;
+  save = vi.fn(async (model: FlowModel) => ({ success: true, uid: model.uid }));
+
+  async findOne() {
+    return this.findOneResult ? JSON.parse(JSON.stringify(this.findOneResult)) : null;
+  }
+
+  async destroy() {
+    return true;
+  }
+
+  async move() {}
+
+  async duplicate() {
+    return null;
+  }
+}
+
+describe('FlowEngine model loaders', () => {
+  let engine: FlowEngine;
+  let repo: MockFlowModelRepository;
+
+  beforeEach(() => {
+    engine = new FlowEngine();
+    repo = new MockFlowModelRepository();
+    engine.setModelRepository(repo);
+  });
+
+  it('resolves explicit and meta-default model trees before synchronous creation', async () => {
+    class ParentModel extends FlowModel {}
+    class ChildModel extends FlowModel {}
+    class DefaultChildModel extends FlowModel {}
+
+    ParentModel.define({
+      createModelOptions: {
+        subModels: {
+          defaultChild: {
+            use: 'DefaultChildModel',
+          },
+        },
+      },
+    });
+
+    const parentLoader = vi.fn(async () => ({ ParentModel }));
+    const childLoader = vi.fn(async () => ({ ChildModel }));
+    const defaultChildLoader = vi.fn(async () => ({ DefaultChildModel }));
+
+    engine.registerModelLoaders({
+      ParentModel: { loader: parentLoader },
+      ChildModel: { loader: childLoader },
+      DefaultChildModel: { loader: defaultChildLoader },
+    });
+
+    const model = await engine.loadOrCreateModel({
+      uid: 'parent-model',
+      use: 'ParentModel',
+      subModels: {
+        child: {
+          use: 'ChildModel',
+        },
+      },
+    });
+
+    expect(model).toBeInstanceOf(ParentModel);
+    expect(model?.subModels.child).toBeInstanceOf(ChildModel);
+    expect(model?.subModels.defaultChild).toBeInstanceOf(DefaultChildModel);
+    expect(parentLoader).toHaveBeenCalledTimes(1);
+    expect(childLoader).toHaveBeenCalledTimes(1);
+    expect(defaultChildLoader).toHaveBeenCalledTimes(1);
+  });
+
+  it('resolves repository-loaded model trees before loadModel creates instances', async () => {
+    class RepoRootModel extends FlowModel {}
+    class RepoChildModel extends FlowModel {}
+
+    const rootLoader = vi.fn(async () => ({ RepoRootModel }));
+    const childLoader = vi.fn(async () => ({ RepoChildModel }));
+
+    engine.registerModelLoaders({
+      RepoRootModel: { loader: rootLoader },
+      RepoChildModel: { loader: childLoader },
+    });
+
+    repo.findOneResult = {
+      uid: 'repo-root',
+      use: 'RepoRootModel',
+      subModels: {
+        child: {
+          use: 'RepoChildModel',
+        },
+      },
+    };
+
+    const model = await engine.loadModel({ uid: 'repo-root' });
+
+    expect(model).toBeInstanceOf(RepoRootModel);
+    expect(model?.subModels.child).toBeInstanceOf(RepoChildModel);
+    expect(rootLoader).toHaveBeenCalledTimes(1);
+    expect(childLoader).toHaveBeenCalledTimes(1);
+  });
+
+  it('supports async model creation and async getters', async () => {
+    class AsyncRootModel extends FlowModel {}
+    class AsyncChildModel extends FlowModel {}
+
+    const rootLoader = vi.fn(async () => ({ AsyncRootModel }));
+    const childLoader = vi.fn(async () => ({ AsyncChildModel }));
+
+    engine.registerModelLoaders({
+      AsyncRootModel: { loader: rootLoader },
+      AsyncChildModel: { loader: childLoader },
+    });
+
+    const rootClass = await engine.getModelClassAsync('AsyncRootModel');
+    const classes = await engine.getModelClassesAsync();
+    const model = await engine.createModelAsync({
+      uid: 'async-root',
+      use: 'AsyncRootModel',
+      subModels: {
+        child: {
+          use: 'AsyncChildModel',
+        },
+      },
+    });
+
+    expect(rootClass).toBe(AsyncRootModel);
+    expect(classes.get('AsyncRootModel')).toBe(AsyncRootModel);
+    expect(classes.get('AsyncChildModel')).toBe(AsyncChildModel);
+    expect(model).toBeInstanceOf(AsyncRootModel);
+    expect(model.subModels.child).toBeInstanceOf(AsyncChildModel);
+    expect(rootLoader).toHaveBeenCalledTimes(1);
+    expect(childLoader).toHaveBeenCalledTimes(1);
+  });
+
+  it('createModelAsync degrades unresolved loader failures to ErrorFlowModel', async () => {
+    const invalidLoader = vi.fn(async () => ({ notAModel: {} }));
+
+    engine.registerModelLoaders({
+      BrokenRootModel: { loader: invalidLoader as any },
+    });
+
+    const model = await engine.createModelAsync({
+      uid: 'broken-root',
+      use: 'BrokenRootModel',
+    });
+
+    expect(model).toBeInstanceOf(ErrorFlowModel);
+    expect(invalidLoader).toHaveBeenCalledTimes(1);
+  });
+
+  it('keeps loader resolution idempotent across resolveModelTree and flow settings preload', async () => {
+    class RuntimeResolvedModel extends FlowModel {}
+    class DesignResolvedModel extends FlowModel {}
+
+    const runtimeLoader = vi.fn(async () => ({ RuntimeResolvedModel }));
+    const designLoader = vi.fn(async () => ({ DesignResolvedModel }));
+
+    engine.registerModelLoaders({
+      RuntimeResolvedModel: { loader: runtimeLoader },
+      DesignResolvedModel: { loader: designLoader },
+    });
+
+    await engine.resolveModelTree({
+      use: 'RuntimeResolvedModel',
+    });
+
+    const firstPreload = await engine.preloadModelLoaders();
+    const secondPreload = await engine.preloadModelLoaders();
+
+    expect(runtimeLoader).toHaveBeenCalledTimes(1);
+    expect(designLoader).toHaveBeenCalledTimes(1);
+    expect(firstPreload.loaded).toContain('DesignResolvedModel');
+    expect(firstPreload.loaded).not.toContain('RuntimeResolvedModel');
+    expect(secondPreload.loaded).toHaveLength(0);
+    expect(secondPreload.failed).toHaveLength(0);
+  });
+
+  it('picks up newly registered loaders after preload has already completed', async () => {
+    class FirstModel extends FlowModel {}
+    class SecondModel extends FlowModel {}
+
+    const firstLoader = vi.fn(async () => ({ FirstModel }));
+    const secondLoader = vi.fn(async () => ({ SecondModel }));
+
+    engine.registerModelLoaders({
+      FirstModel: { loader: firstLoader },
+    });
+
+    await engine.preloadModelLoaders();
+    expect(firstLoader).toHaveBeenCalledTimes(1);
+    expect(engine.getModelClass('FirstModel')).toBe(FirstModel);
+
+    engine.registerModelLoaders({
+      SecondModel: { loader: secondLoader },
+    });
+
+    const result = await engine.preloadModelLoaders();
+
+    expect(secondLoader).toHaveBeenCalledTimes(1);
+    expect(result.loaded).toContain('SecondModel');
+    expect(engine.getModelClass('SecondModel')).toBe(SecondModel);
+  });
+
+  it('degrades unresolved loader failures to ErrorFlowModel instead of crashing runtime creation', async () => {
+    class ParentModel extends FlowModel {}
+
+    const parentLoader = vi.fn(async () => ({ ParentModel }));
+    const invalidChildLoader = vi.fn(async () => ({ notAModel: {} }));
+
+    engine.registerModelLoaders({
+      ParentModel: { loader: parentLoader },
+      BrokenChildModel: { loader: invalidChildLoader as any },
+    });
+
+    const model = await engine.loadOrCreateModel({
+      uid: 'parent-with-broken-child',
+      use: 'ParentModel',
+      subModels: {
+        child: {
+          use: 'BrokenChildModel',
+        },
+      },
+    });
+
+    expect(model).toBeInstanceOf(ParentModel);
+    expect(model?.subModels.child).toBeInstanceOf(ErrorFlowModel);
+    expect(parentLoader).toHaveBeenCalledTimes(1);
+    expect(invalidChildLoader).toHaveBeenCalledTimes(1);
+  });
+});

package/src/__tests__/flowSettings.test.ts

@@ -8,6 +8,10 @@
  */
 
 import { describe, test, expect, beforeEach, afterEach, vi } from 'vitest';
+import React from 'react';
+import { createForm } from '@formily/core';
+import { createSchemaField, FormProvider } from '@formily/react';
+import { render, screen } from '@testing-library/react';
 import { FlowSettings } from '../flowSettings';
 import { DefaultSettingsIcon } from '../components/settings/wrappers/contextual/DefaultSettingsIcon';
 import { FlowModel } from '../models';
@@ -142,10 +146,10 @@ describe('FlowSettings', () => {
       expect(settingsItem?.sort).toBe(0);
     });
 
-    test('should set up observable properties', () => {
+    test('should set up observable properties', async () => {
       // Test that enabled property is reactive
       const initialEnabled = flowSettings.enabled;
-      flowSettings.enable();
+      await flowSettings.enable();
       expect(flowSettings.enabled).not.toBe(initialEnabled);
       expect(flowSettings.enabled).toBe(true);
     });
@@ -186,6 +190,43 @@ describe('FlowSettings', () => {
       flowSettings.registerComponents({});
       expect(Object.keys(flowSettings.components)).toHaveLength(0);
     });
+
+    test('should register component loaders and load component on render', async () => {
+      const loader = vi.fn(async () => ({
+        default: () => React.createElement('div', null, 'Lazy Flow Settings Component'),
+      }));
+
+      flowSettings.registerComponentLoaders({
+        DemoFlowSettingsLazyField: loader,
+      });
+
+      expect(loader).not.toHaveBeenCalled();
+
+      const SchemaField = createSchemaField();
+      const form = createForm();
+
+      render(
+        React.createElement(
+          FormProvider,
+          { form },
+          React.createElement(SchemaField, {
+            schema: {
+              type: 'object',
+              properties: {
+                demo: {
+                  type: 'void',
+                  'x-component': 'DemoFlowSettingsLazyField',
+                },
+              },
+            },
+            components: flowSettings.components,
+          }),
+        ),
+      );
+
+      expect(await screen.findByText('Lazy Flow Settings Component')).toBeInTheDocument();
+      expect(loader).toHaveBeenCalledTimes(1);
+    });
   });
 
   describe('Scope Registration', () => {
@@ -228,30 +269,68 @@ describe('FlowSettings', () => {
   });
 
   describe('Enable/Disable Functionality', () => {
-    test('should enable flow settings', () => {
+    test('should enable flow settings', async () => {
       expect(flowSettings.enabled).toBe(false);
 
-      flowSettings.enable();
+      await flowSettings.enable();
 
       expect(flowSettings.enabled).toBe(true);
     });
 
-    test('should disable flow settings', () => {
-      flowSettings.enable();
+    test('should preload model loaders before enabling flow settings', async () => {
+      const preloadSpy = vi.spyOn(engine, 'preloadModelLoaders').mockResolvedValue({
+        requested: [],
+        loaded: [],
+        failed: [],
+      });
+
+      await flowSettings.enable();
+
+      expect(preloadSpy).toHaveBeenCalledTimes(1);
       expect(flowSettings.enabled).toBe(true);
+    });
 
-      flowSettings.disable();
+    test('should preload model loaders before force enabling flow settings', async () => {
+      const preloadSpy = vi.spyOn(engine, 'preloadModelLoaders').mockResolvedValue({
+        requested: [],
+        loaded: [],
+        failed: [],
+      });
+
+      await flowSettings.forceEnable();
+
+      expect(preloadSpy).toHaveBeenCalledTimes(1);
+      expect(flowSettings.enabled).toBe(true);
+    });
+
+    test('should disable flow settings', async () => {
+      await flowSettings.enable();
+      expect(flowSettings.enabled).toBe(true);
+
+      await flowSettings.disable();
 
       expect(flowSettings.enabled).toBe(false);
     });
 
-    test('should handle multiple enable/disable calls', () => {
-      flowSettings.enable();
-      flowSettings.enable();
+    test('should handle multiple enable/disable calls', async () => {
+      await flowSettings.enable();
+      await flowSettings.enable();
       expect(flowSettings.enabled).toBe(true);
 
-      flowSettings.disable();
-      flowSettings.disable();
+      await flowSettings.disable();
+      await flowSettings.disable();
+      expect(flowSettings.enabled).toBe(false);
+    });
+
+    test('forceDisable should clear force-enabled state and disable flow settings', async () => {
+      await flowSettings.forceEnable();
+      expect(flowSettings.enabled).toBe(true);
+
+      await flowSettings.forceDisable();
+
+      expect(flowSettings.enabled).toBe(false);
+
+      await flowSettings.disable();
       expect(flowSettings.enabled).toBe(false);
     });
   });
@@ -512,7 +591,7 @@ describe('FlowSettings', () => {
   });
 
   describe('Complex Integration Scenarios', () => {
-    test('should maintain state consistency during multiple operations', () => {
+    test('should maintain state consistency during multiple operations', async () => {
       // Initialize with components and scopes
       const TestComponent = () => 'TestComponent';
       const testScope = () => 'testScope';
@@ -528,7 +607,7 @@ describe('FlowSettings', () => {
       });
 
       // Enable/disable
-      flowSettings.enable();
+      await flowSettings.enable();
       expect(flowSettings.enabled).toBe(true);
 
       // Verify all state is maintained
@@ -536,7 +615,7 @@ describe('FlowSettings', () => {
       expect(flowSettings.scopes.testScope).toBe(testScope);
       expect(flowSettings.getToolbarItems().find((item) => item.key === 'integration-test')).toBeDefined();
 
-      flowSettings.disable();
+      await flowSettings.disable();
       expect(flowSettings.enabled).toBe(false);
 
       // State should still be maintained after disable